//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Date: 16 Nov 2022
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;

namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class AdvSimdIntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / ADVSIMD";

        /// <summary>
        /// int16x4_t vaba_s16 (int16x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VABA.S16 Dd, Dn, Dm
        ///A64: SABA Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vaba_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaba_s16", Category)]
        public object vaba_s16(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// int32x2_t vaba_s32 (int32x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VABA.S32 Dd, Dn, Dm
        ///A64: SABA Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vaba_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaba_s32", Category)]
        public object vaba_s32(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// int8x8_t vaba_s8 (int8x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VABA.S8 Dd, Dn, Dm
        ///A64: SABA Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vaba_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaba_s8", Category)]
        public object vaba_s8(object addend, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// uint16x4_t vaba_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VABA.U16 Dd, Dn, Dm
        ///A64: UABA Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vaba_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaba_u16", Category)]
        public object vaba_u16(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// uint32x2_t vaba_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VABA.U32 Dd, Dn, Dm
        ///A64: UABA Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vaba_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaba_u32", Category)]
        public object vaba_u32(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// uint8x8_t vaba_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VABA.U8 Dd, Dn, Dm
        ///A64: UABA Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vaba_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaba_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaba_u8", Category)]
        public object vaba_u8(object addend, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// int32x4_t vabal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
        ///A32: VABAL.S16 Qd, Dn+1, Dm+1
        ///A64: SABAL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabal_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_high_s16", Category)]
        public object vabal_high_s16(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpperAndAdd);
        
        /// <summary>
        /// int64x2_t vabal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
        ///A32: VABAL.S32 Qd, Dn+1, Dm+1
        ///A64: SABAL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabal_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_high_s32", Category)]
        public object vabal_high_s32(object addend, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpperAndAdd);
        
        /// <summary>
        /// int16x8_t vabal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c)
        ///A32: VABAL.S8 Qd, Dn+1, Dm+1
        ///A64: SABAL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabal_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_high_s8", Category)]
        public object vabal_high_s8(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpperAndAdd);
        
        /// <summary>
        /// uint32x4_t vabal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VABAL.U16 Qd, Dn+1, Dm+1
        ///A64: UABAL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabal_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_high_u16", Category)]
        public object vabal_high_u16(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpperAndAdd);
        
        /// <summary>
        /// uint64x2_t vabal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VABAL.U32 Qd, Dn+1, Dm+1
        ///A64: UABAL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabal_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_high_u32", Category)]
        public object vabal_high_u32(object addend, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpperAndAdd);
        
        /// <summary>
        /// uint16x8_t vabal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VABAL.U8 Qd, Dn+1, Dm+1
        ///A64: UABAL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabal_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_high_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_high_u8", Category)]
        public object vabal_high_u8(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpperAndAdd);
        
        /// <summary>
        /// int32x4_t vabal_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VABAL.S16 Qd, Dn, Dm
        ///A64: SABAL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vabal_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_s16", Category)]
        public object vabal_s16(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLowerAndAdd);
        
        /// <summary>
        /// int64x2_t vabal_s32 (int64x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VABAL.S32 Qd, Dn, Dm
        ///A64: SABAL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabal_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_s32", Category)]
        public object vabal_s32(object addend, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLowerAndAdd);
        
        /// <summary>
        /// int16x8_t vabal_s8 (int16x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VABAL.S8 Qd, Dn, Dm
        ///A64: SABAL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vabal_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_s8", Category)]
        public object vabal_s8(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLowerAndAdd);
        
        /// <summary>
        /// uint32x4_t vabal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VABAL.U16 Qd, Dn, Dm
        ///A64: UABAL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vabal_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_u16", Category)]
        public object vabal_u16(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLowerAndAdd);
        
        /// <summary>
        /// uint64x2_t vabal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VABAL.U32 Qd, Dn, Dm
        ///A64: UABAL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabal_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_u32", Category)]
        public object vabal_u32(object addend, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLowerAndAdd);
        
        /// <summary>
        /// uint16x8_t vabal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VABAL.U8 Qd, Dn, Dm
        ///A64: UABAL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vabal_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabal_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabal_u8", Category)]
        public object vabal_u8(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLowerAndAdd);
        
        /// <summary>
        /// int16x8_t vabaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
        ///A32: VABA.S16 Qd, Qn, Qm
        ///A64: SABA Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabaq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabaq_s16", Category)]
        public object vabaq_s16(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// int32x4_t vabaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
        ///A32: VABA.S32 Qd, Qn, Qm
        ///A64: SABA Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabaq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabaq_s32", Category)]
        public object vabaq_s32(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// int8x16_t vabaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
        ///A32: VABA.S8 Qd, Qn, Qm
        ///A64: SABA Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabaq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabaq_s8", Category)]
        public object vabaq_s8(object addend, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// uint16x8_t vabaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VABA.U16 Qd, Qn, Qm
        ///A64: UABA Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabaq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabaq_u16", Category)]
        public object vabaq_u16(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// uint32x4_t vabaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VABA.U32 Qd, Qn, Qm
        ///A64: UABA Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabaq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabaq_u32", Category)]
        public object vabaq_u32(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// uint8x16_t vabaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VABA.U8 Qd, Qn, Qm
        ///A64: UABA Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabaq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabaq_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabaq_u8", Category)]
        public object vabaq_u8(object addend, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceAdd);
        
        /// <summary>
        /// float32x2_t vabd_f32 (float32x2_t a, float32x2_t b)
        ///A32: VABD.F32 Dd, Dn, Dm
        ///A64: FABD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabd_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_f32", Category)]
        public object vabd_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int16x4_t vabd_s16 (int16x4_t a, int16x4_t b)
        ///A32: VABD.S16 Dd, Dn, Dm
        ///A64: SABD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vabd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_s16", Category)]
        public object vabd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int32x2_t vabd_s32 (int32x2_t a, int32x2_t b)
        ///A32: VABD.S32 Dd, Dn, Dm
        ///A64: SABD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_s32", Category)]
        public object vabd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int8x8_t vabd_s8 (int8x8_t a, int8x8_t b)
        ///A32: VABD.S8 Dd, Dn, Dm
        ///A64: SABD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vabd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_s8", Category)]
        public object vabd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// uint16x4_t vabd_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VABD.U16 Dd, Dn, Dm
        ///A64: UABD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vabd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_u16", Category)]
        public object vabd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// uint32x2_t vabd_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VABD.U32 Dd, Dn, Dm
        ///A64: UABD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_u32", Category)]
        public object vabd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// uint8x8_t vabd_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VABD.U8 Dd, Dn, Dm
        ///A64: UABD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vabd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_u8", Category)]
        public object vabd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int32x4_t vabdl_high_s16 (int16x8_t a, int16x8_t b)
        ///A32: VABDL.S16 Qd, Dn+1, Dm+1
        ///A64: SABDL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabdl_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_high_s16", Category)]
        public object vabdl_high_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpper);
        
        /// <summary>
        /// int64x2_t vabdl_high_s32 (int32x4_t a, int32x4_t b)
        ///A32: VABDL.S32 Qd, Dn+1, Dm+1
        ///A64: SABDL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabdl_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_high_s32", Category)]
        public object vabdl_high_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpper);
        
        /// <summary>
        /// int16x8_t vabdl_high_s8 (int8x16_t a, int8x16_t b)
        ///A32: VABDL.S8 Qd, Dn+1, Dm+1
        ///A64: SABDL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabdl_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_high_s8", Category)]
        public object vabdl_high_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpper);
        
        /// <summary>
        /// uint32x4_t vabdl_high_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VABDL.U16 Qd, Dn+1, Dm+1
        ///A64: UABDL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabdl_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_high_u16", Category)]
        public object vabdl_high_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpper);
        
        /// <summary>
        /// uint64x2_t vabdl_high_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VABDL.U32 Qd, Dn+1, Dm+1
        ///A64: UABDL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabdl_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_high_u32", Category)]
        public object vabdl_high_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpper);
        
        /// <summary>
        /// uint16x8_t vabdl_high_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VABDL.U8 Qd, Dn+1, Dm+1
        ///A64: UABDL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabdl_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_high_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_high_u8", Category)]
        public object vabdl_high_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningUpper);
        
        /// <summary>
        /// int32x4_t vabdl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VABDL.S16 Qd, Dn, Dm
        ///A64: SABDL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vabdl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_s16", Category)]
        public object vabdl_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLower);
        
        /// <summary>
        /// int64x2_t vabdl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VABDL.S32 Qd, Dn, Dm
        ///A64: SABDL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabdl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_s32", Category)]
        public object vabdl_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLower);
        
        /// <summary>
        /// int16x8_t vabdl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VABDL.S8 Qd, Dn, Dm
        ///A64: SABDL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vabdl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_s8", Category)]
        public object vabdl_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLower);
        
        /// <summary>
        /// uint32x4_t vabdl_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VABDL.U16 Qd, Dn, Dm
        ///A64: UABDL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vabdl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_u16", Category)]
        public object vabdl_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLower);
        
        /// <summary>
        /// uint64x2_t vabdl_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VABDL.U32 Qd, Dn, Dm
        ///A64: UABDL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vabdl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_u32", Category)]
        public object vabdl_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLower);
        
        /// <summary>
        /// uint16x8_t vabdl_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VABDL.U8 Qd, Dn, Dm
        ///A64: UABDL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vabdl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdl_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdl_u8", Category)]
        public object vabdl_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifferenceWideningLower);
        
        /// <summary>
        /// float32x4_t vabdq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VABD.F32 Qd, Qn, Qm
        ///A64: FABD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabdq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_f32", Category)]
        public object vabdq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int16x8_t vabdq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VABD.S16 Qd, Qn, Qm
        ///A64: SABD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabdq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_s16", Category)]
        public object vabdq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int32x4_t vabdq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VABD.S32 Qd, Qn, Qm
        ///A64: SABD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabdq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_s32", Category)]
        public object vabdq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// int8x16_t vabdq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VABD.S8 Qd, Qn, Qm
        ///A64: SABD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabdq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_s8", Category)]
        public object vabdq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// uint16x8_t vabdq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VABD.U16 Qd, Qn, Qm
        ///A64: UABD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vabdq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_u16", Category)]
        public object vabdq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// uint32x4_t vabdq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VABD.U32 Qd, Qn, Qm
        ///A64: UABD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vabdq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_u32", Category)]
        public object vabdq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// uint8x16_t vabdq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VABD.U8 Qd, Qn, Qm
        ///A64: UABD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vabdq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_u8", Category)]
        public object vabdq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteDifference);
        
        /// <summary>
        /// float32x2_t vabs_f32 (float32x2_t a)
        ///A32: VABS.F32 Dd, Dm
        ///A64: FABS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vabs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabs_f32", Category)]
        public object vabs_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// float64x1_t vabs_f64 (float64x1_t a)
        ///A32: VABS.F64 Dd, Dm
        ///A64: FABS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vabs_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabs_f64", Category)]
        public object vabs_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsScalar);
        
        /// <summary>
        /// int16x4_t vabs_s16 (int16x4_t a)
        ///A32: VABS.S16 Dd, Dm
        ///A64: ABS Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vabs_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabs_s16", Category)]
        public object vabs_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// int32x2_t vabs_s32 (int32x2_t a)
        ///A32: VABS.S32 Dd, Dm
        ///A64: ABS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vabs_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabs_s32", Category)]
        public object vabs_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// int8x8_t vabs_s8 (int8x8_t a)
        ///A32: VABS.S8 Dd, Dm
        ///A64: ABS Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vabs_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabs_s8", Category)]
        public object vabs_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// float32x4_t vabsq_f32 (float32x4_t a)
        ///A32: VABS.F32 Qd, Qm
        ///A64: FABS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vabsq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabsq_f32", Category)]
        public object vabsq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// int16x8_t vabsq_s16 (int16x8_t a)
        ///A32: VABS.S16 Qd, Qm
        ///A64: ABS Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vabsq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabsq_s16", Category)]
        public object vabsq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// int32x4_t vabsq_s32 (int32x4_t a)
        ///A32: VABS.S32 Qd, Qm
        ///A64: ABS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vabsq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabsq_s32", Category)]
        public object vabsq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// int8x16_t vabsq_s8 (int8x16_t a)
        ///A32: VABS.S8 Qd, Qm
        ///A64: ABS Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vabsq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabsq_s8", Category)]
        public object vabsq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Abs);
        
        /// <summary>
        /// float32_t vabss_f32 (float32_t a)
        ///A32: VABS.F32 Sd, Sm
        ///A64: FABS Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vabss_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabss_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabss_f32", Category)]
        public object vabss_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsScalar);
        
        /// <summary>
        /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b)
        ///A32: VADD.F32 Dd, Dn, Dm
        ///A64: FADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vadd_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_f32", Category)]
        public object vadd_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b)
        ///A32: VADD.F64 Dd, Dn, Dm
        ///A64: FADD Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vadd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_f64", Category)]
        public object vadd_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddScalar);
        
        /// <summary>
        /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b)
        ///A32: VADD.I16 Dd, Dn, Dm
        ///A64: ADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vadd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_s16", Category)]
        public object vadd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b)
        ///A32: VADD.I32 Dd, Dn, Dm
        ///A64: ADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vadd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_s32", Category)]
        public object vadd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b)
        ///A32: VADD.I64 Dd, Dn, Dm
        ///A64: ADD Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vadd_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_s64", Category)]
        public object vadd_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddScalar);
        
        /// <summary>
        /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b)
        ///A32: VADD.I8 Dd, Dn, Dm
        ///A64: ADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vadd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_s8", Category)]
        public object vadd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VADD.I16 Dd, Dn, Dm
        ///A64: ADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vadd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_u16", Category)]
        public object vadd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VADD.I32 Dd, Dn, Dm
        ///A64: ADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vadd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_u32", Category)]
        public object vadd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VADD.I64 Dd, Dn, Dm
        ///A64: ADD Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vadd_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_u64", Category)]
        public object vadd_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddScalar);
        
        /// <summary>
        /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VADD.I8 Dd, Dn, Dm
        ///A64: ADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vadd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadd_u8", Category)]
        public object vadd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
        ///A32: VADDHN.I16 Dd+1, Qn, Qm
        ///A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddhn_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_s16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_high_s16", Category)]
        public object vaddhn_high_s16(object lower, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
        ///A32: VADDHN.I32 Dd+1, Qn, Qm
        ///A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddhn_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_s32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_high_s32", Category)]
        public object vaddhn_high_s32(object lower, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
        ///A32: VADDHN.I64 Dd+1, Qn, Qm
        ///A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddhn_high_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_s64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_high_s64", Category)]
        public object vaddhn_high_s64(object lower, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
        ///A32: VADDHN.I16 Dd+1, Qn, Qm
        ///A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddhn_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_u16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_high_u16", Category)]
        public object vaddhn_high_u16(object lower, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
        ///A32: VADDHN.I32 Dd+1, Qn, Qm
        ///A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddhn_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_u32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_high_u32", Category)]
        public object vaddhn_high_u32(object lower, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
        ///A32: VADDHN.I64 Dd+1, Qn, Qm
        ///A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddhn_high_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_high_u64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_high_u64", Category)]
        public object vaddhn_high_u64(object lower, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b)
        ///A32: VADDHN.I16 Dd, Qn, Qm
        ///A64: ADDHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddhn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_s16", Category)]
        public object vaddhn_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingLower);
        
        /// <summary>
        /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b)
        ///A32: VADDHN.I32 Dd, Qn, Qm
        ///A64: ADDHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddhn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_s32", Category)]
        public object vaddhn_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingLower);
        
        /// <summary>
        /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b)
        ///A32: VADDHN.I64 Dd, Qn, Qm
        ///A64: ADDHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddhn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_s64", Category)]
        public object vaddhn_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VADDHN.I16 Dd, Qn, Qm
        ///A64: ADDHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddhn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_u16", Category)]
        public object vaddhn_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VADDHN.I32 Dd, Qn, Qm
        ///A64: ADDHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddhn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_u32", Category)]
        public object vaddhn_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VADDHN.I64 Dd, Qn, Qm
        ///A64: ADDHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddhn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddhn_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddhn_u64", Category)]
        public object vaddhn_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddHighNarrowingLower);
        
        /// <summary>
        /// int32x4_t vaddl_high_s16 (int16x8_t a, int16x8_t b)
        ///A32: VADDL.S16 Qd, Dn+1, Dm+1
        ///A64: SADDL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddl_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_high_s16", Category)]
        public object vaddl_high_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// int64x2_t vaddl_high_s32 (int32x4_t a, int32x4_t b)
        ///A32: VADDL.S32 Qd, Dn+1, Dm+1
        ///A64: SADDL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddl_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_high_s32", Category)]
        public object vaddl_high_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// int16x8_t vaddl_high_s8 (int8x16_t a, int8x16_t b)
        ///A32: VADDL.S8 Qd, Dn+1, Dm+1
        ///A64: SADDL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vaddl_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_high_s8", Category)]
        public object vaddl_high_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// uint32x4_t vaddl_high_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VADDL.U16 Qd, Dn+1, Dm+1
        ///A64: UADDL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddl_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_high_u16", Category)]
        public object vaddl_high_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// uint64x2_t vaddl_high_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VADDL.U32 Qd, Dn+1, Dm+1
        ///A64: UADDL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddl_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_high_u32", Category)]
        public object vaddl_high_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// uint16x8_t vaddl_high_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VADDL.U8 Qd, Dn+1, Dm+1
        ///A64: UADDL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vaddl_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_high_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_high_u8", Category)]
        public object vaddl_high_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// int32x4_t vaddl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VADDL.S16 Qd, Dn, Dm
        ///A64: SADDL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vaddl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_s16", Category)]
        public object vaddl_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// int64x2_t vaddl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VADDL.S32 Qd, Dn, Dm
        ///A64: SADDL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vaddl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_s32", Category)]
        public object vaddl_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// int16x8_t vaddl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VADDL.S8 Qd, Dn, Dm
        ///A64: SADDL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vaddl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_s8", Category)]
        public object vaddl_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// uint32x4_t vaddl_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VADDL.U16 Qd, Dn, Dm
        ///A64: UADDL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vaddl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_u16", Category)]
        public object vaddl_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// uint64x2_t vaddl_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VADDL.U32 Qd, Dn, Dm
        ///A64: UADDL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vaddl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_u32", Category)]
        public object vaddl_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// uint16x8_t vaddl_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VADDL.U8 Qd, Dn, Dm
        ///A64: UADDL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vaddl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddl_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddl_u8", Category)]
        public object vaddl_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VADD.F32 Qd, Qn, Qm
        ///A64: FADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_f32", Category)]
        public object vaddq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VADD.I16 Qd, Qn, Qm
        ///A64: ADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_s16", Category)]
        public object vaddq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VADD.I32 Qd, Qn, Qm
        ///A64: ADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_s32", Category)]
        public object vaddq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VADD.I64 Qd, Qn, Qm
        ///A64: ADD Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_s64", Category)]
        public object vaddq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VADD.I8 Qd, Qn, Qm
        ///A64: ADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vaddq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_s8", Category)]
        public object vaddq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VADD.I16 Qd, Qn, Qm
        ///A64: ADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_u16", Category)]
        public object vaddq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VADD.I32 Qd, Qn, Qm
        ///A64: ADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_u32", Category)]
        public object vaddq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VADD.I64 Qd, Qn, Qm
        ///A64: ADD Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_u64", Category)]
        public object vaddq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VADD.I8 Qd, Qn, Qm
        ///A64: ADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vaddq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_u8", Category)]
        public object vaddq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Add);
        
        /// <summary>
        /// float32_t vadds_f32 (float32_t a, float32_t b)
        ///A32: VADD.F32 Sd, Sn, Sm
        ///A64: FADD Sd, Sn, Sm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vadds_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadds_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vadds_f32", Category)]
        public object vadds_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddScalar);
        
        /// <summary>
        /// int32x4_t vaddw_high_s16 (int32x4_t a, int16x8_t b)
        ///A32: VADDW.S16 Qd, Qn, Dm+1
        ///A64: SADDW2 Vd.4S, Vn.4S, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddw_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_high_s16", Category)]
        public object vaddw_high_s16(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// int64x2_t vaddw_high_s32 (int64x2_t a, int32x4_t b)
        ///A32: VADDW.S32 Qd, Qn, Dm+1
        ///A64: SADDW2 Vd.2D, Vn.2D, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddw_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_high_s32", Category)]
        public object vaddw_high_s32(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// int16x8_t vaddw_high_s8 (int16x8_t a, int8x16_t b)
        ///A32: VADDW.S8 Qd, Qn, Dm+1
        ///A64: SADDW2 Vd.8H, Vn.8H, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vaddw_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_high_s8", Category)]
        public object vaddw_high_s8(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// uint32x4_t vaddw_high_u16 (uint32x4_t a, uint16x8_t b)
        ///A32: VADDW.U16 Qd, Qn, Dm+1
        ///A64: UADDW2 Vd.4S, Vn.4S, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vaddw_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_high_u16", Category)]
        public object vaddw_high_u16(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// uint64x2_t vaddw_high_u32 (uint64x2_t a, uint32x4_t b)
        ///A32: VADDW.U32 Qd, Qn, Dm+1
        ///A64: UADDW2 Vd.2D, Vn.2D, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vaddw_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_high_u32", Category)]
        public object vaddw_high_u32(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// uint16x8_t vaddw_high_u8 (uint16x8_t a, uint8x16_t b)
        ///A32: VADDW.U8 Qd, Qn, Dm+1
        ///A64: UADDW2 Vd.8H, Vn.8H, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vaddw_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_high_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_high_u8", Category)]
        public object vaddw_high_u8(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningUpper);
        
        /// <summary>
        /// int32x4_t vaddw_s16 (int32x4_t a, int16x4_t b)
        ///A32: VADDW.S16 Qd, Qn, Dm
        ///A64: SADDW Vd.4S, Vn.4S, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vaddw_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_s16", Category)]
        public object vaddw_s16(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// int64x2_t vaddw_s32 (int64x2_t a, int32x2_t b)
        ///A32: VADDW.S32 Qd, Qn, Dm
        ///A64: SADDW Vd.2D, Vn.2D, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vaddw_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_s32", Category)]
        public object vaddw_s32(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// int16x8_t vaddw_s8 (int16x8_t a, int8x8_t b)
        ///A32: VADDW.S8 Qd, Qn, Dm
        ///A64: SADDW Vd.8H, Vn.8H, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vaddw_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_s8", Category)]
        public object vaddw_s8(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// uint32x4_t vaddw_u16 (uint32x4_t a, uint16x4_t b)
        ///A32: VADDW.U16 Qd, Qn, Dm
        ///A64: UADDW Vd.4S, Vn.4S, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vaddw_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_u16", Category)]
        public object vaddw_u16(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// uint64x2_t vaddw_u32 (uint64x2_t a, uint32x2_t b)
        ///A32: VADDW.U32 Qd, Qn, Dm
        ///A64: UADDW Vd.2D, Vn.2D, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vaddw_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_u32", Category)]
        public object vaddw_u32(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// uint16x8_t vaddw_u8 (uint16x8_t a, uint8x8_t b)
        ///A32: VADDW.U8 Qd, Qn, Dm
        ///A64: UADDW Vd.8H, Vn.8H, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vaddw_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddw_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddw_u8", Category)]
        public object vaddw_u8(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddWideningLower);
        
        /// <summary>
        /// float32x2_t vand_f32 (float32x2_t a, float32x2_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vand_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_f32", Category)]
        public object vand_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// float64x1_t vand_f64 (float64x1_t a, float64x1_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vand_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_f64", Category)]
        public object vand_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int16x4_t vand_s16 (int16x4_t a, int16x4_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_s16", Category)]
        public object vand_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int32x2_t vand_s32 (int32x2_t a, int32x2_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_s32", Category)]
        public object vand_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int64x1_t vand_s64 (int64x1_t a, int64x1_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_s64", Category)]
        public object vand_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int8x8_t vand_s8 (int8x8_t a, int8x8_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_s8", Category)]
        public object vand_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint16x4_t vand_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_u16", Category)]
        public object vand_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint32x2_t vand_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_u32", Category)]
        public object vand_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint64x1_t vand_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_u64", Category)]
        public object vand_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint8x8_t vand_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VAND Dd, Dn, Dm
        ///A64: AND Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vand_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vand_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vand_u8", Category)]
        public object vand_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// float32x4_t vandq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vandq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_f32", Category)]
        public object vandq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// float64x2_t vandq_f64 (float64x2_t a, float64x2_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vandq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_f64", Category)]
        public object vandq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int16x8_t vandq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_s16", Category)]
        public object vandq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int32x4_t vandq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_s32", Category)]
        public object vandq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int64x2_t vandq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_s64", Category)]
        public object vandq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// int8x16_t vandq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_s8", Category)]
        public object vandq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint16x8_t vandq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_u16", Category)]
        public object vandq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint32x4_t vandq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_u32", Category)]
        public object vandq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint64x2_t vandq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_u64", Category)]
        public object vandq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// uint8x16_t vandq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VAND Qd, Qn, Qm
        ///A64: AND Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vandq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vandq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vandq_u8", Category)]
        public object vandq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.And);
        
        /// <summary>
        /// float32x2_t vbic_f32 (float32x2_t a, float32x2_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vbic_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_f32)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_f32", Category)]
        public object vbic_f32(object value, object mask) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// float64x1_t vbic_f64 (float64x1_t a, float64x1_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vbic_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_f64)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_f64", Category)]
        public object vbic_f64(object value, object mask) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int16x4_t vbic_s16 (int16x4_t a, int16x4_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s16)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_s16", Category)]
        public object vbic_s16(object value, object mask) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int32x2_t vbic_s32 (int32x2_t a, int32x2_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s32)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_s32", Category)]
        public object vbic_s32(object value, object mask) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int64x1_t vbic_s64 (int64x1_t a, int64x1_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s64)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_s64", Category)]
        public object vbic_s64(object value, object mask) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int8x8_t vbic_s8 (int8x8_t a, int8x8_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_s8)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_s8", Category)]
        public object vbic_s8(object value, object mask) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint16x4_t vbic_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u16)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_u16", Category)]
        public object vbic_u16(object value, object mask) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint32x2_t vbic_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u32)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_u32", Category)]
        public object vbic_u32(object value, object mask) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint64x1_t vbic_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u64)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_u64", Category)]
        public object vbic_u64(object value, object mask) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint8x8_t vbic_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VBIC Dd, Dn, Dm
        ///A64: BIC Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbic_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbic_u8)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbic_u8", Category)]
        public object vbic_u8(object value, object mask) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// float32x4_t vbicq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vbicq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_f32)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_f32", Category)]
        public object vbicq_f32(object value, object mask) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// float64x2_t vbicq_f64 (float64x2_t a, float64x2_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vbicq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_f64)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_f64", Category)]
        public object vbicq_f64(object value, object mask) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int16x8_t vbicq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s16)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_s16", Category)]
        public object vbicq_s16(object value, object mask) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int32x4_t vbicq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s32)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_s32", Category)]
        public object vbicq_s32(object value, object mask) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int64x2_t vbicq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s64)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_s64", Category)]
        public object vbicq_s64(object value, object mask) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// int8x16_t vbicq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_s8)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_s8", Category)]
        public object vbicq_s8(object value, object mask) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint16x8_t vbicq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u16)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_u16", Category)]
        public object vbicq_u16(object value, object mask) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint32x4_t vbicq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u32)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_u32", Category)]
        public object vbicq_u32(object value, object mask) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint64x2_t vbicq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u64)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_u64", Category)]
        public object vbicq_u64(object value, object mask) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// uint8x16_t vbicq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VBIC Qd, Qn, Qm
        ///A64: BIC Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbicq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbicq_u8)
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("vbicq_u8", Category)]
        public object vbicq_u8(object value, object mask) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, mask, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseClear);
        
        /// <summary>
        /// float32x2_t vbsl_f32 (uint32x2_t a, float32x2_t b, float32x2_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_f32)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_f32", Category)]
        public object vbsl_f32(object select, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// float64x1_t vbsl_f64 (uint64x1_t a, float64x1_t b, float64x1_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_f64)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_f64", Category)]
        public object vbsl_f64(object select, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int16x4_t vbsl_s16 (uint16x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s16)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_s16", Category)]
        public object vbsl_s16(object select, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int32x2_t vbsl_s32 (uint32x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s32)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_s32", Category)]
        public object vbsl_s32(object select, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int64x1_t vbsl_s64 (uint64x1_t a, int64x1_t b, int64x1_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s64)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_s64", Category)]
        public object vbsl_s64(object select, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int8x8_t vbsl_s8 (uint8x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_s8)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_s8", Category)]
        public object vbsl_s8(object select, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint16x4_t vbsl_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u16)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_u16", Category)]
        public object vbsl_u16(object select, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint32x2_t vbsl_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u32)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_u32", Category)]
        public object vbsl_u32(object select, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint64x1_t vbsl_u64 (uint64x1_t a, uint64x1_t b, uint64x1_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u64)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_u64", Category)]
        public object vbsl_u64(object select, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint8x8_t vbsl_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VBSL Dd, Dn, Dm
        ///A64: BSL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vbsl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbsl_u8)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbsl_u8", Category)]
        public object vbsl_u8(object select, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// float32x4_t vbslq_f32 (uint32x4_t a, float32x4_t b, float32x4_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_f32)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_f32", Category)]
        public object vbslq_f32(object select, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// float64x2_t vbslq_f64 (uint64x2_t a, float64x2_t b, float64x2_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_f64)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_f64", Category)]
        public object vbslq_f64(object select, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int16x8_t vbslq_s16 (uint16x8_t a, int16x8_t b, int16x8_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s16)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_s16", Category)]
        public object vbslq_s16(object select, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int32x4_t vbslq_s32 (uint32x4_t a, int32x4_t b, int32x4_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s32)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_s32", Category)]
        public object vbslq_s32(object select, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int64x2_t vbslq_s64 (uint64x2_t a, int64x2_t b, int64x2_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s64)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_s64", Category)]
        public object vbslq_s64(object select, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// int8x16_t vbslq_s8 (uint8x16_t a, int8x16_t b, int8x16_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_s8)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_s8", Category)]
        public object vbslq_s8(object select, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint16x8_t vbslq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u16)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_u16", Category)]
        public object vbslq_u16(object select, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint32x4_t vbslq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u32)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_u32", Category)]
        public object vbslq_u32(object select, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint64x2_t vbslq_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u64)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_u64", Category)]
        public object vbslq_u64(object select, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint8x16_t vbslq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VBSL Qd, Qn, Qm
        ///A64: BSL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vbslq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vbslq_u8)
        /// <param name="select"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vbslq_u8", Category)]
        public object vbslq_u8(object select, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(select, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.BitwiseSelect);
        
        /// <summary>
        /// uint32x2_t vcage_f32 (float32x2_t a, float32x2_t b)
        ///A32: VACGE.F32 Dd, Dn, Dm
        ///A64: FACGE Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcage_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcage_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcage_f32", Category)]
        public object vcage_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcageq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VACGE.F32 Qd, Qn, Qm
        ///A64: FACGE Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcageq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcageq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcageq_f32", Category)]
        public object vcageq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcagt_f32 (float32x2_t a, float32x2_t b)
        ///A32: VACGT.F32 Dd, Dn, Dm
        ///A64: FACGT Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcagt_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagt_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcagt_f32", Category)]
        public object vcagt_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareGreaterThan);
        
        /// <summary>
        /// uint32x4_t vcagtq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VACGT.F32 Qd, Qn, Qm
        ///A64: FACGT Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcagtq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagtq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcagtq_f32", Category)]
        public object vcagtq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareGreaterThan);
        
        /// <summary>
        /// uint32x2_t vcale_f32 (float32x2_t a, float32x2_t b)
        ///A32: VACLE.F32 Dd, Dn, Dm
        ///A64: FACGE Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcale_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcale_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcale_f32", Category)]
        public object vcale_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcaleq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VACLE.F32 Qd, Qn, Qm
        ///A64: FACGE Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcaleq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaleq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcaleq_f32", Category)]
        public object vcaleq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcalt_f32 (float32x2_t a, float32x2_t b)
        ///A32: VACLT.F32 Dd, Dn, Dm
        ///A64: FACGT Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcalt_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalt_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcalt_f32", Category)]
        public object vcalt_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareLessThan);
        
        /// <summary>
        /// uint32x4_t vcaltq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VACLT.F32 Qd, Qn, Qm
        ///A64: FACGT Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcaltq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaltq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcaltq_f32", Category)]
        public object vcaltq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AbsoluteCompareLessThan);
        
        /// <summary>
        /// uint32x2_t vceq_f32 (float32x2_t a, float32x2_t b)
        ///A32: VCEQ.F32 Dd, Dn, Dm
        ///A64: FCMEQ Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vceq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_f32", Category)]
        public object vceq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint16x4_t vceq_s16 (int16x4_t a, int16x4_t b)
        ///A32: VCEQ.I16 Dd, Dn, Dm
        ///A64: CMEQ Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vceq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_s16", Category)]
        public object vceq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint32x2_t vceq_s32 (int32x2_t a, int32x2_t b)
        ///A32: VCEQ.I32 Dd, Dn, Dm
        ///A64: CMEQ Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vceq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_s32", Category)]
        public object vceq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint8x8_t vceq_s8 (int8x8_t a, int8x8_t b)
        ///A32: VCEQ.I8 Dd, Dn, Dm
        ///A64: CMEQ Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vceq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_s8", Category)]
        public object vceq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint16x4_t vceq_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VCEQ.I16 Dd, Dn, Dm
        ///A64: CMEQ Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vceq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_u16", Category)]
        public object vceq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint32x2_t vceq_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VCEQ.I32 Dd, Dn, Dm
        ///A64: CMEQ Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vceq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_u32", Category)]
        public object vceq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint8x8_t vceq_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VCEQ.I8 Dd, Dn, Dm
        ///A64: CMEQ Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vceq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_u8", Category)]
        public object vceq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint32x4_t vceqq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VCEQ.F32 Qd, Qn, Qm
        ///A64: FCMEQ Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vceqq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_f32", Category)]
        public object vceqq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint16x8_t vceqq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VCEQ.I16 Qd, Qn, Qm
        ///A64: CMEQ Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vceqq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_s16", Category)]
        public object vceqq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint32x4_t vceqq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VCEQ.I32 Qd, Qn, Qm
        ///A64: CMEQ Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vceqq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_s32", Category)]
        public object vceqq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint8x16_t vceqq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VCEQ.I8 Qd, Qn, Qm
        ///A64: CMEQ Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vceqq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_s8", Category)]
        public object vceqq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint16x8_t vceqq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VCEQ.I16 Qd, Qn, Qm
        ///A64: CMEQ Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vceqq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_u16", Category)]
        public object vceqq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint32x4_t vceqq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VCEQ.I32 Qd, Qn, Qm
        ///A64: CMEQ Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vceqq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_u32", Category)]
        public object vceqq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint8x16_t vceqq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VCEQ.I8 Qd, Qn, Qm
        ///A64: CMEQ Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vceqq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_u8", Category)]
        public object vceqq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareEqual);
        
        /// <summary>
        /// uint32x2_t vcge_f32 (float32x2_t a, float32x2_t b)
        ///A32: VCGE.F32 Dd, Dn, Dm
        ///A64: FCMGE Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcge_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_f32", Category)]
        public object vcge_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint16x4_t vcge_s16 (int16x4_t a, int16x4_t b)
        ///A32: VCGE.S16 Dd, Dn, Dm
        ///A64: CMGE Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vcge_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_s16", Category)]
        public object vcge_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcge_s32 (int32x2_t a, int32x2_t b)
        ///A32: VCGE.S32 Dd, Dn, Dm
        ///A64: CMGE Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcge_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_s32", Category)]
        public object vcge_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint8x8_t vcge_s8 (int8x8_t a, int8x8_t b)
        ///A32: VCGE.S8 Dd, Dn, Dm
        ///A64: CMGE Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vcge_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_s8", Category)]
        public object vcge_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint16x4_t vcge_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VCGE.U16 Dd, Dn, Dm
        ///A64: CMHS Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vcge_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_u16", Category)]
        public object vcge_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcge_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VCGE.U32 Dd, Dn, Dm
        ///A64: CMHS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcge_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_u32", Category)]
        public object vcge_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint8x8_t vcge_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VCGE.U8 Dd, Dn, Dm
        ///A64: CMHS Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vcge_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_u8", Category)]
        public object vcge_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcgeq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VCGE.F32 Qd, Qn, Qm
        ///A64: FCMGE Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcgeq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_f32", Category)]
        public object vcgeq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint16x8_t vcgeq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VCGE.S16 Qd, Qn, Qm
        ///A64: CMGE Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcgeq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_s16", Category)]
        public object vcgeq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcgeq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VCGE.S32 Qd, Qn, Qm
        ///A64: CMGE Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcgeq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_s32", Category)]
        public object vcgeq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint8x16_t vcgeq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VCGE.S8 Qd, Qn, Qm
        ///A64: CMGE Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcgeq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_s8", Category)]
        public object vcgeq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint16x8_t vcgeq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VCGE.U16 Qd, Qn, Qm
        ///A64: CMHS Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcgeq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_u16", Category)]
        public object vcgeq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcgeq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VCGE.U32 Qd, Qn, Qm
        ///A64: CMHS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcgeq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_u32", Category)]
        public object vcgeq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint8x16_t vcgeq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VCGE.U8 Qd, Qn, Qm
        ///A64: CMHS Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcgeq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_u8", Category)]
        public object vcgeq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcgt_f32 (float32x2_t a, float32x2_t b)
        ///A32: VCGT.F32 Dd, Dn, Dm
        ///A64: FCMGT Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcgt_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_f32", Category)]
        public object vcgt_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint16x4_t vcgt_s16 (int16x4_t a, int16x4_t b)
        ///A32: VCGT.S16 Dd, Dn, Dm
        ///A64: CMGT Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vcgt_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_s16", Category)]
        public object vcgt_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint32x2_t vcgt_s32 (int32x2_t a, int32x2_t b)
        ///A32: VCGT.S32 Dd, Dn, Dm
        ///A64: CMGT Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcgt_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_s32", Category)]
        public object vcgt_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint8x8_t vcgt_s8 (int8x8_t a, int8x8_t b)
        ///A32: VCGT.S8 Dd, Dn, Dm
        ///A64: CMGT Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vcgt_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_s8", Category)]
        public object vcgt_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint16x4_t vcgt_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VCGT.U16 Dd, Dn, Dm
        ///A64: CMHI Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vcgt_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_u16", Category)]
        public object vcgt_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint32x2_t vcgt_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VCGT.U32 Dd, Dn, Dm
        ///A64: CMHI Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcgt_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_u32", Category)]
        public object vcgt_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint8x8_t vcgt_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VCGT.U8 Dd, Dn, Dm
        ///A64: CMHI Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vcgt_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_u8", Category)]
        public object vcgt_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint32x4_t vcgtq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VCGT.F32 Qd, Qn, Qm
        ///A64: FCMGT Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcgtq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_f32", Category)]
        public object vcgtq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint16x8_t vcgtq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VCGT.S16 Qd, Qn, Qm
        ///A64: CMGT Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcgtq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_s16", Category)]
        public object vcgtq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint32x4_t vcgtq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VCGT.S32 Qd, Qn, Qm
        ///A64: CMGT Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcgtq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_s32", Category)]
        public object vcgtq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint8x16_t vcgtq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VCGT.S8 Qd, Qn, Qm
        ///A64: CMGT Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcgtq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_s8", Category)]
        public object vcgtq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint16x8_t vcgtq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VCGT.U16 Qd, Qn, Qm
        ///A64: CMHI Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcgtq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_u16", Category)]
        public object vcgtq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint32x4_t vcgtq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VCGT.U32 Qd, Qn, Qm
        ///A64: CMHI Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcgtq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_u32", Category)]
        public object vcgtq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint8x16_t vcgtq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VCGT.U8 Qd, Qn, Qm
        ///A64: CMHI Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcgtq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_u8", Category)]
        public object vcgtq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareGreaterThan);
        
        /// <summary>
        /// uint32x2_t vcle_f32 (float32x2_t a, float32x2_t b)
        ///A32: VCLE.F32 Dd, Dn, Dm
        ///A64: FCMGE Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcle_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_f32", Category)]
        public object vcle_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint16x4_t vcle_s16 (int16x4_t a, int16x4_t b)
        ///A32: VCLE.S16 Dd, Dn, Dm
        ///A64: CMGE Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vcle_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_s16", Category)]
        public object vcle_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcle_s32 (int32x2_t a, int32x2_t b)
        ///A32: VCLE.S32 Dd, Dn, Dm
        ///A64: CMGE Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcle_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_s32", Category)]
        public object vcle_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint8x8_t vcle_s8 (int8x8_t a, int8x8_t b)
        ///A32: VCLE.S8 Dd, Dn, Dm
        ///A64: CMGE Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vcle_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_s8", Category)]
        public object vcle_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint16x4_t vcle_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VCLE.U16 Dd, Dn, Dm
        ///A64: CMHS Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vcle_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_u16", Category)]
        public object vcle_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x2_t vcle_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VCLE.U32 Dd, Dn, Dm
        ///A64: CMHS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vcle_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_u32", Category)]
        public object vcle_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint8x8_t vcle_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VCLE.U8 Dd, Dn, Dm
        ///A64: CMHS Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vcle_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_u8", Category)]
        public object vcle_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcleq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VCLE.F32 Qd, Qn, Qm
        ///A64: FCMGE Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcleq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_f32", Category)]
        public object vcleq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint16x8_t vcleq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VCLE.S16 Qd, Qn, Qm
        ///A64: CMGE Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcleq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_s16", Category)]
        public object vcleq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcleq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VCLE.S32 Qd, Qn, Qm
        ///A64: CMGE Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcleq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_s32", Category)]
        public object vcleq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint8x16_t vcleq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VCLE.S8 Qd, Qn, Qm
        ///A64: CMGE Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcleq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_s8", Category)]
        public object vcleq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint16x8_t vcleq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VCLE.U16 Qd, Qn, Qm
        ///A64: CMHS Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcleq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_u16", Category)]
        public object vcleq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint32x4_t vcleq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VCLE.U32 Qd, Qn, Qm
        ///A64: CMHS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcleq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_u32", Category)]
        public object vcleq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint8x16_t vcleq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VCLE.U8 Qd, Qn, Qm
        ///A64: CMHS Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcleq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_u8", Category)]
        public object vcleq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThanOrEqual);
        
        /// <summary>
        /// int16x4_t vcls_s16 (int16x4_t a)
        ///A32: VCLS.S16 Dd, Dm
        ///A64: CLS Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vcls_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcls_s16", Category)]
        public object vcls_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingSignCount);
        
        /// <summary>
        /// int32x2_t vcls_s32 (int32x2_t a)
        ///A32: VCLS.S32 Dd, Dm
        ///A64: CLS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcls_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcls_s32", Category)]
        public object vcls_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingSignCount);
        
        /// <summary>
        /// int8x8_t vcls_s8 (int8x8_t a)
        ///A32: VCLS.S8 Dd, Dm
        ///A64: CLS Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vcls_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcls_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcls_s8", Category)]
        public object vcls_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingSignCount);
        
        /// <summary>
        /// int16x8_t vclsq_s16 (int16x8_t a)
        ///A32: VCLS.S16 Qd, Qm
        ///A64: CLS Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vclsq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclsq_s16", Category)]
        public object vclsq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingSignCount);
        
        /// <summary>
        /// int32x4_t vclsq_s32 (int32x4_t a)
        ///A32: VCLS.S32 Qd, Qm
        ///A64: CLS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vclsq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclsq_s32", Category)]
        public object vclsq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingSignCount);
        
        /// <summary>
        /// int8x16_t vclsq_s8 (int8x16_t a)
        ///A32: VCLS.S8 Qd, Qm
        ///A64: CLS Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vclsq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclsq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclsq_s8", Category)]
        public object vclsq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingSignCount);
        
        /// <summary>
        /// uint32x2_t vclt_f32 (float32x2_t a, float32x2_t b)
        ///A32: VCLT.F32 Dd, Dn, Dm
        ///A64: FCMGT Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vclt_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_f32", Category)]
        public object vclt_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint16x4_t vclt_s16 (int16x4_t a, int16x4_t b)
        ///A32: VCLT.S16 Dd, Dn, Dm
        ///A64: CMGT Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vclt_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_s16", Category)]
        public object vclt_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint32x2_t vclt_s32 (int32x2_t a, int32x2_t b)
        ///A32: VCLT.S32 Dd, Dn, Dm
        ///A64: CMGT Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vclt_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_s32", Category)]
        public object vclt_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint8x8_t vclt_s8 (int8x8_t a, int8x8_t b)
        ///A32: VCLT.S8 Dd, Dn, Dm
        ///A64: CMGT Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vclt_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_s8", Category)]
        public object vclt_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint16x4_t vclt_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VCLT.U16 Dd, Dn, Dm
        ///A64: CMHI Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vclt_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_u16", Category)]
        public object vclt_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint32x2_t vclt_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VCLT.U32 Dd, Dn, Dm
        ///A64: CMHI Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vclt_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_u32", Category)]
        public object vclt_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint8x8_t vclt_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VCLT.U8 Dd, Dn, Dm
        ///A64: CMHI Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vclt_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_u8", Category)]
        public object vclt_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint32x4_t vcltq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VCLT.F32 Qd, Qn, Qm
        ///A64: FCMGT Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcltq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_f32", Category)]
        public object vcltq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint16x8_t vcltq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VCLT.S16 Qd, Qn, Qm
        ///A64: CMGT Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcltq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_s16", Category)]
        public object vcltq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint32x4_t vcltq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VCLT.S32 Qd, Qn, Qm
        ///A64: CMGT Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcltq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_s32", Category)]
        public object vcltq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint8x16_t vcltq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VCLT.S8 Qd, Qn, Qm
        ///A64: CMGT Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcltq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_s8", Category)]
        public object vcltq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint16x8_t vcltq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VCLT.U16 Qd, Qn, Qm
        ///A64: CMHI Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vcltq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_u16", Category)]
        public object vcltq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint32x4_t vcltq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VCLT.U32 Qd, Qn, Qm
        ///A64: CMHI Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vcltq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_u32", Category)]
        public object vcltq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// uint8x16_t vcltq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VCLT.U8 Qd, Qn, Qm
        ///A64: CMHI Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vcltq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_u8", Category)]
        public object vcltq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareLessThan);
        
        /// <summary>
        /// int16x4_t vclz_s16 (int16x4_t a)
        ///A32: VCLZ.I16 Dd, Dm
        ///A64: CLZ Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vclz_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclz_s16", Category)]
        public object vclz_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// int32x2_t vclz_s32 (int32x2_t a)
        ///A32: VCLZ.I32 Dd, Dm
        ///A64: CLZ Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vclz_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclz_s32", Category)]
        public object vclz_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// int8x8_t vclz_s8 (int8x8_t a)
        ///A32: VCLZ.I8 Dd, Dm
        ///A64: CLZ Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vclz_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclz_s8", Category)]
        public object vclz_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// uint16x4_t vclz_u16 (uint16x4_t a)
        ///A32: VCLZ.I16 Dd, Dm
        ///A64: CLZ Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vclz_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclz_u16", Category)]
        public object vclz_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// uint32x2_t vclz_u32 (uint32x2_t a)
        ///A32: VCLZ.I32 Dd, Dm
        ///A64: CLZ Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vclz_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclz_u32", Category)]
        public object vclz_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// uint8x8_t vclz_u8 (uint8x8_t a)
        ///A32: VCLZ.I8 Dd, Dm
        ///A64: CLZ Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vclz_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclz_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclz_u8", Category)]
        public object vclz_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// int16x8_t vclzq_s16 (int16x8_t a)
        ///A32: VCLZ.I16 Qd, Qm
        ///A64: CLZ Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vclzq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclzq_s16", Category)]
        public object vclzq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// int32x4_t vclzq_s32 (int32x4_t a)
        ///A32: VCLZ.I32 Qd, Qm
        ///A64: CLZ Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vclzq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclzq_s32", Category)]
        public object vclzq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// int8x16_t vclzq_s8 (int8x16_t a)
        ///A32: VCLZ.I8 Qd, Qm
        ///A64: CLZ Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vclzq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclzq_s8", Category)]
        public object vclzq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// uint16x8_t vclzq_u16 (uint16x8_t a)
        ///A32: VCLZ.I16 Qd, Qm
        ///A64: CLZ Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vclzq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclzq_u16", Category)]
        public object vclzq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// uint32x4_t vclzq_u32 (uint32x4_t a)
        ///A32: VCLZ.I32 Qd, Qm
        ///A64: CLZ Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vclzq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclzq_u32", Category)]
        public object vclzq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// uint8x16_t vclzq_u8 (uint8x16_t a)
        ///A32: VCLZ.I8 Qd, Qm
        ///A64: CLZ Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vclzq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclzq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vclzq_u8", Category)]
        public object vclzq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.LeadingZeroCount);
        
        /// <summary>
        /// int8x8_t vcnt_s8 (int8x8_t a)
        ///A32: VCNT.I8 Dd, Dm
        ///A64: CNT Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vcnt_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcnt_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcnt_s8", Category)]
        public object vcnt_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.PopCount);
        
        /// <summary>
        /// uint8x8_t vcnt_u8 (uint8x8_t a)
        ///A32: VCNT.I8 Dd, Dm
        ///A64: CNT Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vcnt_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcnt_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcnt_u8", Category)]
        public object vcnt_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.PopCount);
        
        /// <summary>
        /// int8x16_t vcntq_s8 (int8x16_t a)
        ///A32: VCNT.I8 Qd, Qm
        ///A64: CNT Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vcntq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcntq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcntq_s8", Category)]
        public object vcntq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.PopCount);
        
        /// <summary>
        /// uint8x16_t vcntq_u8 (uint8x16_t a)
        ///A32: VCNT.I8 Qd, Qm
        ///A64: CNT Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vcntq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcntq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcntq_u8", Category)]
        public object vcntq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.PopCount);
        
        /// <summary>
        /// float32x2_t vcvt_f32_s32 (int32x2_t a)
        ///A32: VCVT.F32.S32 Dd, Dm
        ///A64: SCVTF Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvt_f32_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_f32_s32", Category)]
        public object vcvt_f32_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToSingle);
        
        /// <summary>
        /// float32x2_t vcvt_f32_u32 (uint32x2_t a)
        ///A32: VCVT.F32.U32 Dd, Dm
        ///A64: UCVTF Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvt_f32_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_f32_u32", Category)]
        public object vcvt_f32_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToSingle);
        
        /// <summary>
        /// int32x2_t vcvt_s32_f32 (float32x2_t a)
        ///A32: VCVT.S32.F32 Dd, Dm
        ///A64: FCVTZS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvt_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_s32_f32", Category)]
        public object vcvt_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToZero);
        
        /// <summary>
        /// uint32x2_t vcvt_u32_f32 (float32x2_t a)
        ///A32: VCVT.U32.F32 Dd, Dm
        ///A64: FCVTZU Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvt_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_u32_f32", Category)]
        public object vcvt_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToZero);
        
        /// <summary>
        /// int32x2_t vcvta_s32_f32 (float32x2_t a)
        ///A32: VCVTA.S32.F32 Dd, Dm
        ///A64: FCVTAS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvta_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvta_s32_f32", Category)]
        public object vcvta_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundAwayFromZero);
        
        /// <summary>
        /// uint32x2_t vcvta_u32_f32 (float32x2_t a)
        ///A32: VCVTA.U32.F32 Dd, Dm
        ///A64: FCVTAU Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvta_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvta_u32_f32", Category)]
        public object vcvta_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundAwayFromZero);
        
        /// <summary>
        /// int32x4_t vcvtaq_s32_f32 (float32x4_t a)
        ///A32: VCVTA.S32.F32 Qd, Qm
        ///A64: FCVTAS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtaq_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtaq_s32_f32", Category)]
        public object vcvtaq_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundAwayFromZero);
        
        /// <summary>
        /// uint32x4_t vcvtaq_u32_f32 (float32x4_t a)
        ///A32: VCVTA.U32.F32 Qd, Qm
        ///A64: FCVTAU Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtaq_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtaq_u32_f32", Category)]
        public object vcvtaq_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundAwayFromZero);
        
        /// <summary>
        /// int32_t vcvtas_s32_f32 (float32_t a)
        ///A32: VCVTA.S32.F32 Sd, Sm
        ///A64: FCVTAS Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtas_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtas_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtas_s32_f32", Category)]
        public object vcvtas_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundAwayFromZeroScalar);
        
        /// <summary>
        /// uint32_t vcvtas_u32_f32 (float32_t a)
        ///A32: VCVTA.U32.F32 Sd, Sm
        ///A64: FCVTAU Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtas_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtas_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtas_u32_f32", Category)]
        public object vcvtas_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundAwayFromZeroScalar);
        
        /// <summary>
        /// int32x2_t vcvtm_s32_f32 (float32x2_t a)
        ///A32: VCVTM.S32.F32 Dd, Dm
        ///A64: FCVTMS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvtm_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtm_s32_f32", Category)]
        public object vcvtm_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToNegativeInfinity);
        
        /// <summary>
        /// uint32x2_t vcvtm_u32_f32 (float32x2_t a)
        ///A32: VCVTM.U32.F32 Dd, Dm
        ///A64: FCVTMU Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvtm_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtm_u32_f32", Category)]
        public object vcvtm_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToNegativeInfinity);
        
        /// <summary>
        /// int32x4_t vcvtmq_s32_f32 (float32x4_t a)
        ///A32: VCVTM.S32.F32 Qd, Qm
        ///A64: FCVTMS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtmq_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtmq_s32_f32", Category)]
        public object vcvtmq_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToNegativeInfinity);
        
        /// <summary>
        /// uint32x4_t vcvtmq_u32_f32 (float32x4_t a)
        ///A32: VCVTM.U32.F32 Qd, Qm
        ///A64: FCVTMU Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtmq_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtmq_u32_f32", Category)]
        public object vcvtmq_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToNegativeInfinity);
        
        /// <summary>
        /// int32_t vcvtms_s32_f32 (float32_t a)
        ///A32: VCVTM.S32.F32 Sd, Sm
        ///A64: FCVTMS Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtms_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtms_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtms_s32_f32", Category)]
        public object vcvtms_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// uint32_t vcvtms_u32_f32 (float32_t a)
        ///A32: VCVTM.U32.F32 Sd, Sm
        ///A64: FCVTMU Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtms_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtms_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtms_u32_f32", Category)]
        public object vcvtms_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// int32x2_t vcvtn_s32_f32 (float32x2_t a)
        ///A32: VCVTN.S32.F32 Dd, Dm
        ///A64: FCVTNS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvtn_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtn_s32_f32", Category)]
        public object vcvtn_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToEven);
        
        /// <summary>
        /// uint32x2_t vcvtn_u32_f32 (float32x2_t a)
        ///A32: VCVTN.U32.F32 Dd, Dm
        ///A64: FCVTNU Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvtn_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtn_u32_f32", Category)]
        public object vcvtn_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToEven);
        
        /// <summary>
        /// int32x4_t vcvtnq_s32_f32 (float32x4_t a)
        ///A32: VCVTN.S32.F32 Qd, Qm
        ///A64: FCVTNS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtnq_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtnq_s32_f32", Category)]
        public object vcvtnq_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToEven);
        
        /// <summary>
        /// uint32x4_t vcvtnq_u32_f32 (float32x4_t a)
        ///A32: VCVTN.U32.F32 Qd, Qm
        ///A64: FCVTNU Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtnq_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtnq_u32_f32", Category)]
        public object vcvtnq_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToEven);
        
        /// <summary>
        /// int32_t vcvtns_s32_f32 (float32_t a)
        ///A32: VCVTN.S32.F32 Sd, Sm
        ///A64: FCVTNS Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtns_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtns_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtns_s32_f32", Category)]
        public object vcvtns_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToEvenScalar);
        
        /// <summary>
        /// uint32_t vcvtns_u32_f32 (float32_t a)
        ///A32: VCVTN.U32.F32 Sd, Sm
        ///A64: FCVTNU Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtns_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtns_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtns_u32_f32", Category)]
        public object vcvtns_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToEvenScalar);
        
        /// <summary>
        /// int32x2_t vcvtp_s32_f32 (float32x2_t a)
        ///A32: VCVTP.S32.F32 Dd, Dm
        ///A64: FCVTPS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvtp_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtp_s32_f32", Category)]
        public object vcvtp_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToPositiveInfinity);
        
        /// <summary>
        /// uint32x2_t vcvtp_u32_f32 (float32x2_t a)
        ///A32: VCVTP.U32.F32 Dd, Dm
        ///A64: FCVTPU Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvtp_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtp_u32_f32", Category)]
        public object vcvtp_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToPositiveInfinity);
        
        /// <summary>
        /// int32x4_t vcvtpq_s32_f32 (float32x4_t a)
        ///A32: VCVTP.S32.F32 Qd, Qm
        ///A64: FCVTPS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtpq_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtpq_s32_f32", Category)]
        public object vcvtpq_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToPositiveInfinity);
        
        /// <summary>
        /// uint32x4_t vcvtpq_u32_f32 (float32x4_t a)
        ///A32: VCVTP.U32.F32 Qd, Qm
        ///A64: FCVTPU Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtpq_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtpq_u32_f32", Category)]
        public object vcvtpq_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToPositiveInfinity);
        
        /// <summary>
        /// int32_t vcvtps_s32_f32 (float32_t a)
        ///A32: VCVTP.S32.F32 Sd, Sm
        ///A64: FCVTPS Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtps_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtps_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtps_s32_f32", Category)]
        public object vcvtps_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// uint32_t vcvtps_u32_f32 (float32_t a)
        ///A32: VCVTP.U32.F32 Sd, Sm
        ///A64: FCVTPU Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvtps_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtps_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtps_u32_f32", Category)]
        public object vcvtps_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// float32x4_t vcvtq_f32_s32 (int32x4_t a)
        ///A32: VCVT.F32.S32 Qd, Qm
        ///A64: SCVTF Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtq_f32_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f32_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_f32_s32", Category)]
        public object vcvtq_f32_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToSingle);
        
        /// <summary>
        /// float32x4_t vcvtq_f32_u32 (uint32x4_t a)
        ///A32: VCVT.F32.U32 Qd, Qm
        ///A64: UCVTF Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtq_f32_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f32_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_f32_u32", Category)]
        public object vcvtq_f32_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToSingle);
        
        /// <summary>
        /// int32x4_t vcvtq_s32_f32 (float32x4_t a)
        ///A32: VCVT.S32.F32 Qd, Qm
        ///A64: FCVTZS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtq_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_s32_f32", Category)]
        public object vcvtq_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToZero);
        
        /// <summary>
        /// uint32x4_t vcvtq_u32_f32 (float32x4_t a)
        ///A32: VCVT.U32.F32 Qd, Qm
        ///A64: FCVTZU Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvtq_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_u32_f32", Category)]
        public object vcvtq_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToZero);
        
        /// <summary>
        /// float32_t vcvts_f32_s32 (int32_t a)
        ///A32: VCVT.F32.S32 Sd, Sm
        ///A64: SCVTF Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvts_f32_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_f32_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvts_f32_s32", Category)]
        public object vcvts_f32_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToSingleScalar);
        
        /// <summary>
        /// float32_t vcvts_f32_u32 (uint32_t a)
        ///A32: VCVT.F32.U32 Sd, Sm
        ///A64: UCVTF Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvts_f32_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_f32_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvts_f32_u32", Category)]
        public object vcvts_f32_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToSingleScalar);
        
        /// <summary>
        /// int32_t vcvts_s32_f32 (float32_t a)
        ///A32: VCVT.S32.F32 Sd, Sm
        ///A64: FCVTZS Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvts_s32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_s32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvts_s32_f32", Category)]
        public object vcvts_s32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToInt32RoundToZeroScalar);
        
        /// <summary>
        /// uint32_t vcvts_u32_f32 (float32_t a)
        ///A32: VCVT.U32.F32 Sd, Sm
        ///A64: FCVTZU Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vcvts_u32_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvts_u32_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvts_u32_f32", Category)]
        public object vcvts_u32_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ConvertToUInt32RoundToZeroScalar);
        
        /// <summary>
        /// float64x1_t vdiv_f64 (float64x1_t a, float64x1_t b)
        ///A32: VDIV.F64 Dd, Dn, Dm
        ///A64: FDIV Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vdiv_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdiv_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vdiv_f64", Category)]
        public object vdiv_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.DivideScalar);
        
        /// <summary>
        /// float32_t vdivs_f32 (float32_t a, float32_t b)
        ///A32: VDIV.F32 Sd, Sn, Sm
        ///A64: FDIV Sd, Sn, Sm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vdivs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivs_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vdivs_f32", Category)]
        public object vdivs_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.DivideScalar);
        
        /// <summary>
        /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane)
        ///A32: VDUP.32 Dd, Dm[index]
        ///A64: DUP Vd.2S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_f32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_f32", Category)]
        public object vdup_lane_f32(object value, byte index) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane)
        ///A32: VDUP.16 Dd, Dm[index]
        ///A64: DUP Vd.4H, Vn.H[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_s16", Category)]
        public object vdup_lane_s16(object value, byte index) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane)
        ///A32: VDUP.32 Dd, Dm[index]
        ///A64: DUP Vd.2S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_s32", Category)]
        public object vdup_lane_s32(object value, byte index) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane)
        ///A32: VDUP.8 Dd, Dm[index]
        ///A64: DUP Vd.8B, Vn.B[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_s8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_s8", Category)]
        public object vdup_lane_s8(object value, byte index) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane)
        ///A32: VDUP.16 Dd, Dm[index]
        ///A64: DUP Vd.4H, Vn.H[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_u16", Category)]
        public object vdup_lane_u16(object value, byte index) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane)
        ///A32: VDUP.32 Dd, Dm[index]
        ///A64: DUP Vd.2S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_u32", Category)]
        public object vdup_lane_u32(object value, byte index) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// uint8x8_t vdup_lane_u8 (uint8x8_t vec, const int lane)
        ///A32: VDUP.8 Dd, Dm[index]
        ///A64: DUP Vd.8B, Vn.B[index]
        ///
        ///
        ///Instruction Documentation: [vdup_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_lane_u8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_lane_u8", Category)]
        public object vdup_lane_u8(object value, byte index) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane)
        ///A32: VDUP.32 Dd, Dm[index]
        ///A64: DUP Vd.2S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_f32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_f32", Category)]
        public object vdup_laneq_f32(object value, byte index) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane)
        ///A32: VDUP.16 Dd, Dm[index]
        ///A64: DUP Vd.4H, Vn.H[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_s16", Category)]
        public object vdup_laneq_s16(object value, byte index) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane)
        ///A32: VDUP.32 Dd, Dm[index]
        ///A64: DUP Vd.2S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_s32", Category)]
        public object vdup_laneq_s32(object value, byte index) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane)
        ///A32: VDUP.8 Dd, Dm[index]
        ///A64: DUP Vd.8B, Vn.B[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_s8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_s8", Category)]
        public object vdup_laneq_s8(object value, byte index) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane)
        ///A32: VDUP.16 Dd, Dm[index]
        ///A64: DUP Vd.4H, Vn.H[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_u16", Category)]
        public object vdup_laneq_u16(object value, byte index) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane)
        ///A32: VDUP.32 Dd, Dm[index]
        ///A64: DUP Vd.2S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_u32", Category)]
        public object vdup_laneq_u32(object value, byte index) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane)
        ///A32: VDUP.8 Dd, Dm[index]
        ///A64: DUP Vd.8B, Vn.B[index]
        ///
        ///
        ///Instruction Documentation: [vdup_laneq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_laneq_u8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdup_laneq_u8", Category)]
        public object vdup_laneq_u8(object value, byte index) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector64);
        
        /// <summary>
        /// float32x2_t vdup_n_f32 (float32_t value)
        ///A32: VDUP Dd, Dm[0]
        ///A64: DUP Vd.2S, Vn.S[0]
        ///
        ///
        ///Instruction Documentation: [vdup_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_f32", Category)]
        public object vdup_n_f32(float value) => (object)ProcessFunc<float, float, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// int16x4_t vdup_n_s16 (int16_t value)
        ///A32: VDUP.16 Dd, Rt
        ///A64: DUP Vd.4H, Rn
        ///
        ///
        ///Instruction Documentation: [vdup_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_s16", Category)]
        public object vdup_n_s16(short value) => (object)ProcessFunc<short, short, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// int32x2_t vdup_n_s32 (int32_t value)
        ///A32: VDUP.32 Dd, Rt
        ///A64: DUP Vd.2S, Rn
        ///
        ///
        ///Instruction Documentation: [vdup_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_s32", Category)]
        public object vdup_n_s32(int value) => (object)ProcessFunc<int, int, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// int8x8_t vdup_n_s8 (int8_t value)
        ///A32: VDUP.8 Dd, Rt
        ///A64: DUP Vd.8B, Rn
        ///
        ///
        ///Instruction Documentation: [vdup_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_s8", Category)]
        public object vdup_n_s8(sbyte value) => (object)ProcessFunc<sbyte, sbyte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// uint16x4_t vdup_n_u16 (uint16_t value)
        ///A32: VDUP.16 Dd, Rt
        ///A64: DUP Vd.4H, Rn
        ///
        ///
        ///Instruction Documentation: [vdup_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_u16", Category)]
        public object vdup_n_u16(ushort value) => (object)ProcessFunc<ushort, ushort, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// uint32x2_t vdup_n_u32 (uint32_t value)
        ///A32: VDUP.32 Dd, Rt
        ///A64: DUP Vd.2S, Rn
        ///
        ///
        ///Instruction Documentation: [vdup_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_u32", Category)]
        public object vdup_n_u32(uint value) => (object)ProcessFunc<uint, uint, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// uint8x8_t vdup_n_u8 (uint8_t value)
        ///A32: VDUP.8 Dd, Rt
        ///A64: DUP Vd.8B, Rn
        ///
        ///
        ///Instruction Documentation: [vdup_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdup_n_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdup_n_u8", Category)]
        public object vdup_n_u8(byte value) => (object)ProcessFunc<byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector64);
        
        /// <summary>
        /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane)
        ///A32: VDUP.32 Qd, Dm[index]
        ///A64: DUP Vd.4S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_f32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_f32", Category)]
        public object vdupq_lane_f32(object value, byte index) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane)
        ///A32: VDUP.16 Qd, Dm[index]
        ///A64: DUP Vd.8H, Vn.H[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_s16", Category)]
        public object vdupq_lane_s16(object value, byte index) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane)
        ///A32: VDUP.32 Qd, Dm[index]
        ///A64: DUP Vd.4S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_s32", Category)]
        public object vdupq_lane_s32(object value, byte index) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane)
        ///A32: VDUP.8 Qd, Dm[index]
        ///A64: DUP Vd.16B, Vn.B[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_s8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_s8", Category)]
        public object vdupq_lane_s8(object value, byte index) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane)
        ///A32: VDUP.16 Qd, Dm[index]
        ///A64: DUP Vd.8H, Vn.H[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_u16", Category)]
        public object vdupq_lane_u16(object value, byte index) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane)
        ///A32: VDUP.32 Qd, Dm[index]
        ///A64: DUP Vd.4S, Vn.S[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_u32", Category)]
        public object vdupq_lane_u32(object value, byte index) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane)
        ///A32: VDUP.8 Qd, Dm[index]
        ///A64: DUP Vd.16B, Vn.B[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_lane_u8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_lane_u8", Category)]
        public object vdupq_lane_u8(object value, byte index) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// float32x4_t vdupq_n_f32 (float32_t value)
        ///A32: VDUP Qd, Dm[0]
        ///A64: DUP Vd.4S, Vn.S[0]
        ///
        ///
        ///Instruction Documentation: [vdupq_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_f32", Category)]
        public object vdupq_n_f32(float value) => (object)ProcessFunc<float, float, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// int16x8_t vdupq_n_s16 (int16_t value)
        ///A32: VDUP.16 Qd, Rt
        ///A64: DUP Vd.8H, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_s16", Category)]
        public object vdupq_n_s16(short value) => (object)ProcessFunc<short, short, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// int32x4_t vdupq_n_s32 (int32_t value)
        ///A32: VDUP.32 Qd, Rt
        ///A64: DUP Vd.4S, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_s32", Category)]
        public object vdupq_n_s32(int value) => (object)ProcessFunc<int, int, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// int8x16_t vdupq_n_s8 (int8_t value)
        ///A32: VDUP.8 Qd, Rt
        ///A64: DUP Vd.16B, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_s8", Category)]
        public object vdupq_n_s8(sbyte value) => (object)ProcessFunc<sbyte, sbyte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// uint16x8_t vdupq_n_u16 (uint16_t value)
        ///A32: VDUP.16 Qd, Rt
        ///A64: DUP Vd.8H, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_u16", Category)]
        public object vdupq_n_u16(ushort value) => (object)ProcessFunc<ushort, ushort, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// uint32x4_t vdupq_n_u32 (uint32_t value)
        ///A32: VDUP.32 Qd, Rt
        ///A64: DUP Vd.4S, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_u32", Category)]
        public object vdupq_n_u32(uint value) => (object)ProcessFunc<uint, uint, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// uint8x16_t vdupq_n_u8 (uint8_t value)
        ///A32: VDUP.8 Qd, Rt
        ///A64: DUP Vd.16B, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_u8", Category)]
        public object vdupq_n_u8(byte value) => (object)ProcessFunc<byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.DuplicateToVector128);
        
        /// <summary>
        /// float32x2_t veor_f32 (float32x2_t a, float32x2_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [veor_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_f32", Category)]
        public object veor_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// float64x1_t veor_f64 (float64x1_t a, float64x1_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [veor_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_f64", Category)]
        public object veor_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int16x4_t veor_s16 (int16x4_t a, int16x4_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_s16", Category)]
        public object veor_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int32x2_t veor_s32 (int32x2_t a, int32x2_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_s32", Category)]
        public object veor_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int64x1_t veor_s64 (int64x1_t a, int64x1_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_s64", Category)]
        public object veor_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int8x8_t veor_s8 (int8x8_t a, int8x8_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_s8", Category)]
        public object veor_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint16x4_t veor_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_u16", Category)]
        public object veor_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint32x2_t veor_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_u32", Category)]
        public object veor_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint64x1_t veor_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_u64", Category)]
        public object veor_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint8x8_t veor_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VEOR Dd, Dn, Dm
        ///A64: EOR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [veor_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/veor_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veor_u8", Category)]
        public object veor_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// float32x4_t veorq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [veorq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_f32", Category)]
        public object veorq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// float64x2_t veorq_f64 (float64x2_t a, float64x2_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [veorq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_f64", Category)]
        public object veorq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int16x8_t veorq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_s16", Category)]
        public object veorq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int32x4_t veorq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_s32", Category)]
        public object veorq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int64x2_t veorq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_s64", Category)]
        public object veorq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// int8x16_t veorq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_s8", Category)]
        public object veorq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint16x8_t veorq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_u16", Category)]
        public object veorq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint32x4_t veorq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_u32", Category)]
        public object veorq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint64x2_t veorq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_u64", Category)]
        public object veorq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// uint8x16_t veorq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VEOR Qd, Qn, Qm
        ///A64: EOR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [veorq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/veorq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("veorq_u8", Category)]
        public object veorq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Xor);
        
        /// <summary>
        /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n)
        ///A32: VEXT.8 Dd, Dn, Dm, #(n*4)
        ///A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
        ///
        ///
        ///Instruction Documentation: [vext_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_f32)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vext_f32", Category)]
        public object vext_f32(object upper, object lower, byte index) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector64);
        
        /// <summary>
        /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n)
        ///A32: VEXT.8 Dd, Dn, Dm, #(n*2)
        ///A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2)
        ///
        ///
        ///Instruction Documentation: [vext_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s16)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vext_s16", Category)]
        public object vext_s16(object upper, object lower, byte index) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector64);
        
        /// <summary>
        /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n)
        ///A32: VEXT.8 Dd, Dn, Dm, #(n*4)
        ///A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
        ///
        ///
        ///Instruction Documentation: [vext_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s32)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vext_s32", Category)]
        public object vext_s32(object upper, object lower, byte index) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector64);
        
        /// <summary>
        /// uint8x8_t vext_s8 (uint8x8_t a, uint8x8_t b, const int n)
        ///A32: VEXT.8 Dd, Dn, Dm, #n
        ///A64: EXT Vd.8B, Vn.8B, Vm.8B, #n
        ///
        ///
        ///Instruction Documentation: [vext_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vext_s8)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vext_s8", Category)]
        public object vext_s8(object upper, object lower, byte index) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector64);
        
        /// <summary>
        /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n)
        ///A32: VEXT.8 Qd, Qn, Qm, #(n*4)
        ///A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
        ///
        ///
        ///Instruction Documentation: [vextq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_f32)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vextq_f32", Category)]
        public object vextq_f32(object upper, object lower, byte index) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector128);
        
        /// <summary>
        /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n)
        ///A32: VEXT.8 Qd, Qn, Qm, #(n*8)
        ///A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
        ///
        ///
        ///Instruction Documentation: [vextq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_f64)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vextq_f64", Category)]
        public object vextq_f64(object upper, object lower, byte index) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector128);
        
        /// <summary>
        /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n)
        ///A32: VEXT.8 Qd, Qn, Qm, #(n*2)
        ///A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2)
        ///
        ///
        ///Instruction Documentation: [vextq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s16)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vextq_s16", Category)]
        public object vextq_s16(object upper, object lower, byte index) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector128);
        
        /// <summary>
        /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n)
        ///A32: VEXT.8 Qd, Qn, Qm, #(n*4)
        ///A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
        ///
        ///
        ///Instruction Documentation: [vextq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s32)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vextq_s32", Category)]
        public object vextq_s32(object upper, object lower, byte index) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector128);
        
        /// <summary>
        /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n)
        ///A32: VEXT.8 Qd, Qn, Qm, #(n*8)
        ///A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
        ///
        ///
        ///Instruction Documentation: [vextq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s64)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vextq_s64", Category)]
        public object vextq_s64(object upper, object lower, byte index) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector128);
        
        /// <summary>
        /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n)
        ///A32: VEXT.8 Qd, Qn, Qm, #n
        ///A64: EXT Vd.16B, Vn.16B, Vm.16B, #n
        ///
        ///
        ///Instruction Documentation: [vextq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vextq_s8)
        /// <param name="upper"></param>
        /// <param name="lower"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vextq_s8", Category)]
        public object vextq_s8(object upper, object lower, byte index) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(upper, lower, index, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractVector128);
        
        /// <summary>
        /// float32x2_t vfma_f32 (float32x2_t a, float32x2_t b, float32x2_t c)
        ///A32: VFMA.F32 Dd, Dn, Dm
        ///A64: FMLA Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vfma_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfma_f32", Category)]
        public object vfma_f32(object addend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplyAdd);
        
        /// <summary>
        /// float64x1_t vfma_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
        ///A32: VFMA.F64 Dd, Dn, Dm
        ///A64: FMADD Dd, Dn, Dm, Da
        ///
        ///
        ///Instruction Documentation: [vfma_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_f64)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfma_f64", Category)]
        public object vfma_f64(object addend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplyAddScalar);
        
        /// <summary>
        /// float32x4_t vfmaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
        ///A32: VFMA.F32 Qd, Qn, Qm
        ///A64: FMLA Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vfmaq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmaq_f32", Category)]
        public object vfmaq_f32(object addend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplyAdd);
        
        /// <summary>
        /// float32_t vfmas_f32 (float32_t a, float32_t b, float32_t c)
        ///A32: VFMA.F32 Sd, Sn, Sm
        ///A64: FMADD Sd, Sn, Sm, Sa The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vfmas_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmas_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmas_f32", Category)]
        public object vfmas_f32(object addend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplyAddScalar);
        
        /// <summary>
        /// float32x2_t vfms_f32 (float32x2_t a, float32x2_t b, float32x2_t c)
        ///A32: VFMS.F32 Dd, Dn, Dm
        ///A64: FMLS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vfms_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfms_f32", Category)]
        public object vfms_f32(object minuend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplySubtract);
        
        /// <summary>
        /// float64x1_t vfms_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
        ///A32: VFMS.F64 Dd, Dn, Dm
        ///A64: FMSUB Dd, Dn, Dm, Da
        ///
        ///
        ///Instruction Documentation: [vfms_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_f64)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfms_f64", Category)]
        public object vfms_f64(object minuend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplySubtractScalar);
        
        /// <summary>
        /// float32x4_t vfmsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c)
        ///A32: VFMS.F32 Qd, Qn, Qm
        ///A64: FMLS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vfmsq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmsq_f32", Category)]
        public object vfmsq_f32(object minuend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplySubtract);
        
        /// <summary>
        /// float32_t vfmss_f32 (float32_t a, float32_t b, float32_t c)
        ///A32: VFMS.F32 Sd, Sn, Sm
        ///A64: FMSUB Sd, Sn, Sm, Sa The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vfmss_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmss_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmss_f32", Category)]
        public object vfmss_f32(object minuend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplySubtractScalar);
        
        /// <summary>
        /// float64x1_t vfnma_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
        ///A32: VFNMA.F64 Dd, Dn, Dm
        ///A64: FNMADD Dd, Dn, Dm, Da The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vfnma_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfnma_f64)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfnma_f64", Category)]
        public object vfnma_f64(object addend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplyAddNegatedScalar);
        
        /// <summary>
        /// float32_t vfnmas_f32 (float32_t a, float32_t b, float32_t c)
        ///A32: VFNMA.F32 Sd, Sn, Sm
        ///A64: FNMADD Sd, Sn, Sm, Sa The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vfnmas_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfnmas_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfnmas_f32", Category)]
        public object vfnmas_f32(object addend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplyAddNegatedScalar);
        
        /// <summary>
        /// float64x1_t vfnms_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
        ///A32: VFNMS.F64 Dd, Dn, Dm
        ///A64: FNMSUB Dd, Dn, Dm, Da The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vfnms_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfnms_f64)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfnms_f64", Category)]
        public object vfnms_f64(object minuend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplySubtractNegatedScalar);
        
        /// <summary>
        /// float32_t vfnmss_f32 (float32_t a, float32_t b, float32_t c)
        ///A32: VFNMS.F32 Sd, Sn, Sm
        ///A64: FNMSUB Sd, Sn, Sm, Sa The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vfnmss_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfnmss_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfnmss_f32", Category)]
        public object vfnmss_f32(object minuend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedMultiplySubtractNegatedScalar);
        
        /// <summary>
        /// float32_t vget_lane_f32 (float32x2_t v, const int lane)
        ///A32: VMOV.F32 Sd, Sm
        ///A64: DUP Sd, Vn.S[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_f32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_f32", Category)]
        public float vget_lane_f32(object vector, byte index) => (float)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, float>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int16_t vget_lane_s16 (int16x4_t v, const int lane)
        ///A32: VMOV.S16 Rt, Dn[lane]
        ///A64: SMOV Wd, Vn.H[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_s16", Category)]
        public short vget_lane_s16(object vector, byte index) => (short)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, short>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int32_t vget_lane_s32 (int32x2_t v, const int lane)
        ///A32: VMOV.32 Rt, Dn[lane]
        ///A64: SMOV Wd, Vn.S[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_s32", Category)]
        public int vget_lane_s32(object vector, byte index) => (int)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, int>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int8_t vget_lane_s8 (int8x8_t v, const int lane)
        ///A32: VMOV.S8 Rt, Dn[lane]
        ///A64: SMOV Wd, Vn.B[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_s8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_s8", Category)]
        public sbyte vget_lane_s8(object vector, byte index) => (sbyte)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, sbyte>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane)
        ///A32: VMOV.U16 Rt, Dn[lane]
        ///A64: UMOV Wd, Vn.H[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_u16", Category)]
        public ushort vget_lane_u16(object vector, byte index) => (ushort)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, ushort>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane)
        ///A32: VMOV.32 Rt, Dn[lane]
        ///A64: UMOV Wd, Vn.S[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_u32", Category)]
        public uint vget_lane_u32(object vector, byte index) => (uint)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, uint>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint8_t vget_lane_u8 (uint8x8_t v, const int lane)
        ///A32: VMOV.U8 Rt, Dn[lane]
        ///A64: UMOV Wd, Vn.B[lane]
        ///
        ///
        ///Instruction Documentation: [vget_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_u8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vget_lane_u8", Category)]
        public byte vget_lane_u8(object vector, byte index) => (byte)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, byte>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane)
        ///A32: VMOV.F32 Sd, Sm
        ///A64: DUP Sd, Vn.S[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_f32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_f32", Category)]
        public float vgetq_lane_f32(object vector, byte index) => (float)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, float>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane)
        ///A32: VMOV.F64 Dd, Dm
        ///A64: DUP Dd, Vn.D[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_f64)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_f64", Category)]
        public double vgetq_lane_f64(object vector, byte index) => (double)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, double>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane)
        ///A32: VMOV.S16 Rt, Dn[lane]
        ///A64: SMOV Wd, Vn.H[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_s16", Category)]
        public short vgetq_lane_s16(object vector, byte index) => (short)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, short>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane)
        ///A32: VMOV.32 Rt, Dn[lane]
        ///A64: SMOV Wd, Vn.S[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_s32", Category)]
        public int vgetq_lane_s32(object vector, byte index) => (int)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, int>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane)
        ///A32: VMOV Rt, Rt2, Dm
        ///A64: UMOV Xd, Vn.D[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s64)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_s64", Category)]
        public long vgetq_lane_s64(object vector, byte index) => (long)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, long>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane)
        ///A32: VMOV.S8 Rt, Dn[lane]
        ///A64: SMOV Wd, Vn.B[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_s8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_s8", Category)]
        public sbyte vgetq_lane_s8(object vector, byte index) => (sbyte)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, sbyte>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane)
        ///A32: VMOV.U16 Rt, Dn[lane]
        ///A64: UMOV Wd, Vn.H[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_u16", Category)]
        public ushort vgetq_lane_u16(object vector, byte index) => (ushort)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, ushort>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane)
        ///A32: VMOV.32 Rt, Dn[lane]
        ///A64: UMOV Wd, Vn.S[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_u32", Category)]
        public uint vgetq_lane_u32(object vector, byte index) => (uint)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, uint>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane)
        ///A32: VMOV Rt, Rt2, Dm
        ///A64: UMOV Xd, Vn.D[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u64)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_u64", Category)]
        public ulong vgetq_lane_u64(object vector, byte index) => (ulong)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, ulong>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane)
        ///A32: VMOV.U8 Rt, Dn[lane]
        ///A64: UMOV Wd, Vn.B[lane]
        ///
        ///
        ///Instruction Documentation: [vgetq_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_u8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vgetq_lane_u8", Category)]
        public byte vgetq_lane_u8(object vector, byte index) => (byte)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, byte>(vector, index, System.Runtime.Intrinsics.Arm.AdvSimd.Extract);
        
        /// <summary>
        /// int16x4_t vhadd_s16 (int16x4_t a, int16x4_t b)
        ///A32: VHADD.S16 Dd, Dn, Dm
        ///A64: SHADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vhadd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhadd_s16", Category)]
        public object vhadd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// int32x2_t vhadd_s32 (int32x2_t a, int32x2_t b)
        ///A32: VHADD.S32 Dd, Dn, Dm
        ///A64: SHADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vhadd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhadd_s32", Category)]
        public object vhadd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// int8x8_t vhadd_s8 (int8x8_t a, int8x8_t b)
        ///A32: VHADD.S8 Dd, Dn, Dm
        ///A64: SHADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vhadd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhadd_s8", Category)]
        public object vhadd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// uint16x4_t vhadd_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VHADD.U16 Dd, Dn, Dm
        ///A64: UHADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vhadd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhadd_u16", Category)]
        public object vhadd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// uint32x2_t vhadd_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VHADD.U32 Dd, Dn, Dm
        ///A64: UHADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vhadd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhadd_u32", Category)]
        public object vhadd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// uint8x8_t vhadd_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VHADD.U8 Dd, Dn, Dm
        ///A64: UHADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vhadd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhadd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhadd_u8", Category)]
        public object vhadd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// int16x8_t vhaddq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VHADD.S16 Qd, Qn, Qm
        ///A64: SHADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vhaddq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhaddq_s16", Category)]
        public object vhaddq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// int32x4_t vhaddq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VHADD.S32 Qd, Qn, Qm
        ///A64: SHADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vhaddq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhaddq_s32", Category)]
        public object vhaddq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// int8x16_t vhaddq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VHADD.S8 Qd, Qn, Qm
        ///A64: SHADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vhaddq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhaddq_s8", Category)]
        public object vhaddq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// uint16x8_t vhaddq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VHADD.U16 Qd, Qn, Qm
        ///A64: UHADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vhaddq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhaddq_u16", Category)]
        public object vhaddq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// uint32x4_t vhaddq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VHADD.U32 Qd, Qn, Qm
        ///A64: UHADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vhaddq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhaddq_u32", Category)]
        public object vhaddq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// uint8x16_t vhaddq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VHADD.U8 Qd, Qn, Qm
        ///A64: UHADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vhaddq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhaddq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhaddq_u8", Category)]
        public object vhaddq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddHalving);
        
        /// <summary>
        /// int16x4_t vhsub_s16 (int16x4_t a, int16x4_t b)
        ///A32: VHSUB.S16 Dd, Dn, Dm
        ///A64: SHSUB Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vhsub_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsub_s16", Category)]
        public object vhsub_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// int32x2_t vhsub_s32 (int32x2_t a, int32x2_t b)
        ///A32: VHSUB.S32 Dd, Dn, Dm
        ///A64: SHSUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vhsub_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsub_s32", Category)]
        public object vhsub_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// int8x8_t vhsub_s8 (int8x8_t a, int8x8_t b)
        ///A32: VHSUB.S8 Dd, Dn, Dm
        ///A64: SHSUB Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vhsub_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsub_s8", Category)]
        public object vhsub_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// uint16x4_t vhsub_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VHSUB.U16 Dd, Dn, Dm
        ///A64: UHSUB Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vhsub_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsub_u16", Category)]
        public object vhsub_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// uint32x2_t vhsub_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VHSUB.U32 Dd, Dn, Dm
        ///A64: UHSUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vhsub_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsub_u32", Category)]
        public object vhsub_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// uint8x8_t vhsub_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VHSUB.U8 Dd, Dn, Dm
        ///A64: UHSUB Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vhsub_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsub_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsub_u8", Category)]
        public object vhsub_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// int16x8_t vhsubq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VHSUB.S16 Qd, Qn, Qm
        ///A64: SHSUB Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vhsubq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsubq_s16", Category)]
        public object vhsubq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// int32x4_t vhsubq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VHSUB.S32 Qd, Qn, Qm
        ///A64: SHSUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vhsubq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsubq_s32", Category)]
        public object vhsubq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// int8x16_t vhsubq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VHSUB.S8 Qd, Qn, Qm
        ///A64: SHSUB Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vhsubq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsubq_s8", Category)]
        public object vhsubq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// uint16x8_t vhsubq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VHSUB.U16 Qd, Qn, Qm
        ///A64: UHSUB Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vhsubq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsubq_u16", Category)]
        public object vhsubq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// uint32x4_t vhsubq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VHSUB.U32 Qd, Qn, Qm
        ///A64: UHSUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vhsubq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsubq_u32", Category)]
        public object vhsubq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// uint8x16_t vhsubq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VHSUB.U8 Qd, Qn, Qm
        ///A64: UHSUB Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vhsubq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vhsubq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vhsubq_u8", Category)]
        public object vhsubq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedSubtractHalving);
        
        /// <summary>
        /// float32x2_t vld1_dup_f32 (float32_t const * ptr)
        ///A32: VLD1.32 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.2S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_f32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_f32", Category)]
        public object vld1_dup_f32(object address) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector64<float>>(address, AdvSimd_LoadAndReplicateToVector641775);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<float>> AdvSimd_LoadAndReplicateToVector641775 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<float>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((float*)arg0));
        /// <summary>
        /// int16x4_t vld1_dup_s16 (int16_t const * ptr)
        ///A32: VLD1.16 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.4H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_s16", Category)]
        public object vld1_dup_s16(object address) => (object)ProcessFunc<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector64<short>>(address, AdvSimd_LoadAndReplicateToVector641772);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<short>> AdvSimd_LoadAndReplicateToVector641772 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<short>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((short*)arg0));
        /// <summary>
        /// int32x2_t vld1_dup_s32 (int32_t const * ptr)
        ///A32: VLD1.32 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.2S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_s32", Category)]
        public object vld1_dup_s32(object address) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector64<int>>(address, AdvSimd_LoadAndReplicateToVector641773);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<int>> AdvSimd_LoadAndReplicateToVector641773 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<int>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((int*)arg0));
        /// <summary>
        /// int8x8_t vld1_dup_s8 (int8_t const * ptr)
        ///A32: VLD1.8 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.8B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_s8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_s8", Category)]
        public object vld1_dup_s8(object address) => (object)ProcessFunc<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(address, AdvSimd_LoadAndReplicateToVector641774);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>> AdvSimd_LoadAndReplicateToVector641774 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((sbyte*)arg0));
        /// <summary>
        /// uint16x4_t vld1_dup_u16 (uint16_t const * ptr)
        ///A32: VLD1.16 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.4H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_u16", Category)]
        public object vld1_dup_u16(object address) => (object)ProcessFunc<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(address, AdvSimd_LoadAndReplicateToVector641776);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>> AdvSimd_LoadAndReplicateToVector641776 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((ushort*)arg0));
        /// <summary>
        /// uint32x2_t vld1_dup_u32 (uint32_t const * ptr)
        ///A32: VLD1.32 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.2S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_u32", Category)]
        public object vld1_dup_u32(object address) => (object)ProcessFunc<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector64<uint>>(address, AdvSimd_LoadAndReplicateToVector641777);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<uint>> AdvSimd_LoadAndReplicateToVector641777 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<uint>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((uint*)arg0));
        /// <summary>
        /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr)
        ///A32: VLD1.8 { Dd[] }, [Rn]
        ///A64: LD1R { Vt.8B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_dup_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_dup_u8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_dup_u8", Category)]
        public object vld1_dup_u8(object address) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector64<byte>>(address, AdvSimd_LoadAndReplicateToVector641771);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<byte>> AdvSimd_LoadAndReplicateToVector641771 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<byte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector64((byte*)arg0));
        /// <summary>
        /// float32x2_t vld1_f32 (float32_t const * ptr)
        ///A32: VLD1.32 Dd, [Rn]
        ///A64: LD1 Vt.2S, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_f32", Category)]
        public object vld1_f32(object address) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector64<float>>(address, AdvSimd_LoadVector641794);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<float>> AdvSimd_LoadVector641794 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<float>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((float*)arg0));
        /// <summary>
        /// float64x1_t vld1_f64 (float64_t const * ptr)
        ///A32: VLD1.64 Dd, [Rn]
        ///A64: LD1 Vt.1D, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_f64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_f64", Category)]
        public object vld1_f64(object address) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector64<double>>(address, AdvSimd_LoadVector641789);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<double>> AdvSimd_LoadVector641789 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<double>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((double*)arg0));
        /// <summary>
        /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane)
        ///A32: VLD1.32 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_f32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_f32", Category)]
        public object vld1_lane_f32(object value, byte index, object address) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector64<float>>(value, index, address, AdvSimd_LoadAndInsertScalar1761);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<float>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<float>> AdvSimd_LoadAndInsertScalar1761 = new Func<System.Runtime.Intrinsics.Vector64<float>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<float>)arg0, (byte)arg1, (float*)arg2));
        /// <summary>
        /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane)
        ///A32: VLD1.16 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_s16", Category)]
        public object vld1_lane_s16(object value, byte index, object address) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector64<short>>(value, index, address, AdvSimd_LoadAndInsertScalar1758);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<short>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<short>> AdvSimd_LoadAndInsertScalar1758 = new Func<System.Runtime.Intrinsics.Vector64<short>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<short>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<short>)arg0, (byte)arg1, (short*)arg2));
        /// <summary>
        /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane)
        ///A32: VLD1.32 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_s32", Category)]
        public object vld1_lane_s32(object value, byte index, object address) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector64<int>>(value, index, address, AdvSimd_LoadAndInsertScalar1759);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<int>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<int>> AdvSimd_LoadAndInsertScalar1759 = new Func<System.Runtime.Intrinsics.Vector64<int>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<int>)arg0, (byte)arg1, (int*)arg2));
        /// <summary>
        /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane)
        ///A32: VLD1.8 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_s8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_s8", Category)]
        public object vld1_lane_s8(object value, byte index, object address) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, index, address, AdvSimd_LoadAndInsertScalar1760);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<sbyte>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>> AdvSimd_LoadAndInsertScalar1760 = new Func<System.Runtime.Intrinsics.Vector64<sbyte>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<sbyte>)arg0, (byte)arg1, (sbyte*)arg2));
        /// <summary>
        /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane)
        ///A32: VLD1.16 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_u16", Category)]
        public object vld1_lane_u16(object value, byte index, object address) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, index, address, AdvSimd_LoadAndInsertScalar1762);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<ushort>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<ushort>> AdvSimd_LoadAndInsertScalar1762 = new Func<System.Runtime.Intrinsics.Vector64<ushort>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<ushort>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<ushort>)arg0, (byte)arg1, (ushort*)arg2));
        /// <summary>
        /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane)
        ///A32: VLD1.32 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_u32", Category)]
        public object vld1_lane_u32(object value, byte index, object address) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, index, address, AdvSimd_LoadAndInsertScalar1763);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<uint>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<uint>> AdvSimd_LoadAndInsertScalar1763 = new Func<System.Runtime.Intrinsics.Vector64<uint>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<uint>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<uint>)arg0, (byte)arg1, (uint*)arg2));
        /// <summary>
        /// uint8x8_t vld1_lane_u8 (uint8_t const * ptr, uint8x8_t src, const int lane)
        ///A32: VLD1.8 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_lane_u8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_lane_u8", Category)]
        public object vld1_lane_u8(object value, byte index, object address) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, index, address, AdvSimd_LoadAndInsertScalar1757);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector64<byte>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<byte>> AdvSimd_LoadAndInsertScalar1757 = new Func<System.Runtime.Intrinsics.Vector64<byte>, byte, IntPtr, System.Runtime.Intrinsics.Vector64<byte>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector64<byte>)arg0, (byte)arg1, (byte*)arg2));
        /// <summary>
        /// int16x4_t vld1_s16 (int16_t const * ptr)
        ///A32: VLD1.16 Dd, [Rn]
        ///A64: LD1 Vt.4H, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_s16", Category)]
        public object vld1_s16(object address) => (object)ProcessFunc<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector64<short>>(address, AdvSimd_LoadVector641790);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<short>> AdvSimd_LoadVector641790 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<short>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((short*)arg0));
        /// <summary>
        /// int32x2_t vld1_s32 (int32_t const * ptr)
        ///A32: VLD1.32 Dd, [Rn]
        ///A64: LD1 Vt.2S, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_s32", Category)]
        public object vld1_s32(object address) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector64<int>>(address, AdvSimd_LoadVector641791);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<int>> AdvSimd_LoadVector641791 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<int>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((int*)arg0));
        /// <summary>
        /// int64x1_t vld1_s64 (int64_t const * ptr)
        ///A32: VLD1.64 Dd, [Rn]
        ///A64: LD1 Vt.1D, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_s64", Category)]
        public object vld1_s64(object address) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector64<long>>(address, AdvSimd_LoadVector641792);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<long>> AdvSimd_LoadVector641792 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<long>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((long*)arg0));
        /// <summary>
        /// int8x8_t vld1_s8 (int8_t const * ptr)
        ///A32: VLD1.8 Dd, [Rn]
        ///A64: LD1 Vt.8B, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_s8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_s8", Category)]
        public object vld1_s8(object address) => (object)ProcessFunc<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(address, AdvSimd_LoadVector641793);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>> AdvSimd_LoadVector641793 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((sbyte*)arg0));
        /// <summary>
        /// uint16x4_t vld1_u16 (uint16_t const * ptr)
        ///A32: VLD1.16 Dd, [Rn]
        ///A64: LD1 Vt.4H, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_u16", Category)]
        public object vld1_u16(object address) => (object)ProcessFunc<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(address, AdvSimd_LoadVector641795);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>> AdvSimd_LoadVector641795 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((ushort*)arg0));
        /// <summary>
        /// uint32x2_t vld1_u32 (uint32_t const * ptr)
        ///A32: VLD1.32 Dd, [Rn]
        ///A64: LD1 Vt.2S, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_u32", Category)]
        public object vld1_u32(object address) => (object)ProcessFunc<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector64<uint>>(address, AdvSimd_LoadVector641796);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<uint>> AdvSimd_LoadVector641796 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<uint>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((uint*)arg0));
        /// <summary>
        /// uint64x1_t vld1_u64 (uint64_t const * ptr)
        ///A32: VLD1.64 Dd, [Rn]
        ///A64: LD1 Vt.1D, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_u64", Category)]
        public object vld1_u64(object address) => (object)ProcessFunc<IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(address, AdvSimd_LoadVector641797);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<ulong>> AdvSimd_LoadVector641797 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<ulong>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((ulong*)arg0));
        /// <summary>
        /// uint8x8_t vld1_u8 (uint8_t const * ptr)
        ///A32: VLD1.8 Dd, [Rn]
        ///A64: LD1 Vt.8B, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1_u8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1_u8", Category)]
        public object vld1_u8(object address) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector64<byte>>(address, AdvSimd_LoadVector641788);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector64<byte>> AdvSimd_LoadVector641788 = new Func<IntPtr, System.Runtime.Intrinsics.Vector64<byte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector64((byte*)arg0));
        /// <summary>
        /// float32x4_t vld1q_dup_f32 (float32_t const * ptr)
        ///A32: VLD1.32 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.4S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_f32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_f32", Category)]
        public object vld1q_dup_f32(object address) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(address, AdvSimd_LoadAndReplicateToVector1281768);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>> AdvSimd_LoadAndReplicateToVector1281768 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((float*)arg0));
        /// <summary>
        /// int16x8_t vld1q_dup_s16 (int16_t const * ptr)
        ///A32: VLD1.16 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.8H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_s16", Category)]
        public object vld1q_dup_s16(object address) => (object)ProcessFunc<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector128<short>>(address, AdvSimd_LoadAndReplicateToVector1281765);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<short>> AdvSimd_LoadAndReplicateToVector1281765 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<short>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((short*)arg0));
        /// <summary>
        /// int32x4_t vld1q_dup_s32 (int32_t const * ptr)
        ///A32: VLD1.32 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.4S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_s32", Category)]
        public object vld1q_dup_s32(object address) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(address, AdvSimd_LoadAndReplicateToVector1281766);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>> AdvSimd_LoadAndReplicateToVector1281766 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((int*)arg0));
        /// <summary>
        /// int8x16_t vld1q_dup_s8 (int8_t const * ptr)
        ///A32: VLD1.8 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.16B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_s8", Category)]
        public object vld1q_dup_s8(object address) => (object)ProcessFunc<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(address, AdvSimd_LoadAndReplicateToVector1281767);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>> AdvSimd_LoadAndReplicateToVector1281767 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((sbyte*)arg0));
        /// <summary>
        /// uint16x8_t vld1q_dup_u16 (uint16_t const * ptr)
        ///A32: VLD1.16 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.8H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_u16", Category)]
        public object vld1q_dup_u16(object address) => (object)ProcessFunc<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(address, AdvSimd_LoadAndReplicateToVector1281769);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<ushort>> AdvSimd_LoadAndReplicateToVector1281769 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<ushort>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((ushort*)arg0));
        /// <summary>
        /// uint32x4_t vld1q_dup_u32 (uint32_t const * ptr)
        ///A32: VLD1.32 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.4S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_u32", Category)]
        public object vld1q_dup_u32(object address) => (object)ProcessFunc<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector128<uint>>(address, AdvSimd_LoadAndReplicateToVector1281770);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<uint>> AdvSimd_LoadAndReplicateToVector1281770 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<uint>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((uint*)arg0));
        /// <summary>
        /// uint8x16_t vld1q_dup_u8 (uint8_t const * ptr)
        ///A32: VLD1.8 { Dd[], Dd+1[] }, [Rn]
        ///A64: LD1R { Vt.16B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_u8", Category)]
        public object vld1q_dup_u8(object address) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(address, AdvSimd_LoadAndReplicateToVector1281764);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> AdvSimd_LoadAndReplicateToVector1281764 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndReplicateToVector128((byte*)arg0));
        /// <summary>
        /// float32x4_t vld1q_f32 (float32_t const * ptr)
        ///A32: VLD1.32 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.4S, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_f32", Category)]
        public object vld1q_f32(object address) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(address, AdvSimd_LoadVector1281784);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>> AdvSimd_LoadVector1281784 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((float*)arg0));
        /// <summary>
        /// float64x2_t vld1q_f64 (float64_t const * ptr)
        ///A32: VLD1.64 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.2D, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_f64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_f64", Category)]
        public object vld1q_f64(object address) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(address, AdvSimd_LoadVector1281779);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>> AdvSimd_LoadVector1281779 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((double*)arg0));
        /// <summary>
        /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane)
        ///A32: VLD1.32 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_f32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_f32", Category)]
        public object vld1q_lane_f32(object value, byte index, object address) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(value, index, address, AdvSimd_LoadAndInsertScalar1753);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<float>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<float>> AdvSimd_LoadAndInsertScalar1753 = new Func<System.Runtime.Intrinsics.Vector128<float>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<float>)arg0, (byte)arg1, (float*)arg2));
        /// <summary>
        /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane)
        ///A32: VLDR.64 Dd, [Rn]
        ///A64: LD1 { Vt.D }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_f64)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_f64", Category)]
        public object vld1q_lane_f64(object value, byte index, object address) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(value, index, address, AdvSimd_LoadAndInsertScalar1748);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<double>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<double>> AdvSimd_LoadAndInsertScalar1748 = new Func<System.Runtime.Intrinsics.Vector128<double>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<double>)arg0, (byte)arg1, (double*)arg2));
        /// <summary>
        /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane)
        ///A32: VLD1.16 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_s16", Category)]
        public object vld1q_lane_s16(object value, byte index, object address) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector128<short>>(value, index, address, AdvSimd_LoadAndInsertScalar1749);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<short>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<short>> AdvSimd_LoadAndInsertScalar1749 = new Func<System.Runtime.Intrinsics.Vector128<short>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<short>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<short>)arg0, (byte)arg1, (short*)arg2));
        /// <summary>
        /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane)
        ///A32: VLD1.32 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_s32", Category)]
        public object vld1q_lane_s32(object value, byte index, object address) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(value, index, address, AdvSimd_LoadAndInsertScalar1750);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<int>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<int>> AdvSimd_LoadAndInsertScalar1750 = new Func<System.Runtime.Intrinsics.Vector128<int>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<int>)arg0, (byte)arg1, (int*)arg2));
        /// <summary>
        /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane)
        ///A32: VLDR.64 Dd, [Rn]
        ///A64: LD1 { Vt.D }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s64)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_s64", Category)]
        public object vld1q_lane_s64(object value, byte index, object address) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(value, index, address, AdvSimd_LoadAndInsertScalar1751);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<long>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<long>> AdvSimd_LoadAndInsertScalar1751 = new Func<System.Runtime.Intrinsics.Vector128<long>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<long>)arg0, (byte)arg1, (long*)arg2));
        /// <summary>
        /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane)
        ///A32: VLD1.8 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_s8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_s8", Category)]
        public object vld1q_lane_s8(object value, byte index, object address) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, index, address, AdvSimd_LoadAndInsertScalar1752);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<sbyte>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>> AdvSimd_LoadAndInsertScalar1752 = new Func<System.Runtime.Intrinsics.Vector128<sbyte>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<sbyte>)arg0, (byte)arg1, (sbyte*)arg2));
        /// <summary>
        /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane)
        ///A32: VLD1.16 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u16)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_u16", Category)]
        public object vld1q_lane_u16(object value, byte index, object address) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, index, address, AdvSimd_LoadAndInsertScalar1754);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<ushort>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<ushort>> AdvSimd_LoadAndInsertScalar1754 = new Func<System.Runtime.Intrinsics.Vector128<ushort>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<ushort>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<ushort>)arg0, (byte)arg1, (ushort*)arg2));
        /// <summary>
        /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane)
        ///A32: VLD1.32 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u32)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_u32", Category)]
        public object vld1q_lane_u32(object value, byte index, object address) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, index, address, AdvSimd_LoadAndInsertScalar1755);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<uint>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<uint>> AdvSimd_LoadAndInsertScalar1755 = new Func<System.Runtime.Intrinsics.Vector128<uint>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<uint>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<uint>)arg0, (byte)arg1, (uint*)arg2));
        /// <summary>
        /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane)
        ///A32: VLDR.64 Dd, [Rn]
        ///A64: LD1 { Vt.D }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u64)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_u64", Category)]
        public object vld1q_lane_u64(object value, byte index, object address) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, index, address, AdvSimd_LoadAndInsertScalar1756);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<ulong>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<ulong>> AdvSimd_LoadAndInsertScalar1756 = new Func<System.Runtime.Intrinsics.Vector128<ulong>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<ulong>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<ulong>)arg0, (byte)arg1, (ulong*)arg2));
        /// <summary>
        /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane)
        ///A32: VLD1.8 { Dd[index] }, [Rn]
        ///A64: LD1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_lane_u8)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_lane_u8", Category)]
        public object vld1q_lane_u8(object value, byte index, object address) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, index, address, AdvSimd_LoadAndInsertScalar1747);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<byte>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<byte>> AdvSimd_LoadAndInsertScalar1747 = new Func<System.Runtime.Intrinsics.Vector128<byte>, byte, IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadAndInsertScalar((System.Runtime.Intrinsics.Vector128<byte>)arg0, (byte)arg1, (byte*)arg2));
        /// <summary>
        /// int16x8_t vld1q_s16 (int16_t const * ptr)
        ///A32: VLD1.16 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.8H, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s16)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_s16", Category)]
        public object vld1q_s16(object address) => (object)ProcessFunc<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector128<short>>(address, AdvSimd_LoadVector1281780);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<short>> AdvSimd_LoadVector1281780 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<short>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((short*)arg0));
        /// <summary>
        /// int32x4_t vld1q_s32 (int32_t const * ptr)
        ///A32: VLD1.32 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.4S, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s32)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_s32", Category)]
        public object vld1q_s32(object address) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(address, AdvSimd_LoadVector1281781);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>> AdvSimd_LoadVector1281781 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((int*)arg0));
        /// <summary>
        /// int64x2_t vld1q_s64 (int64_t const * ptr)
        ///A32: VLD1.64 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.2D, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_s64", Category)]
        public object vld1q_s64(object address) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(address, AdvSimd_LoadVector1281782);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>> AdvSimd_LoadVector1281782 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((long*)arg0));
        /// <summary>
        /// int8x16_t vld1q_s8 (int8_t const * ptr)
        ///A32: VLD1.8 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.16B, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_s8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_s8", Category)]
        public object vld1q_s8(object address) => (object)ProcessFunc<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(address, AdvSimd_LoadVector1281783);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>> AdvSimd_LoadVector1281783 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((sbyte*)arg0));
        /// <summary>
        /// uint64x2_t vld1q_u64 (uint64_t const * ptr)
        ///A32: VLD1.64 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.2D, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_u64", Category)]
        public object vld1q_u64(object address) => (object)ProcessFunc<IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(address, AdvSimd_LoadVector1281787);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>> AdvSimd_LoadVector1281787 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((ulong*)arg0));
        /// <summary>
        /// uint8x16_t vld1q_u8 (uint8_t const * ptr)
        ///A32: VLD1.8 Dd, Dd+1, [Rn]
        ///A64: LD1 Vt.16B, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_u8)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_u8", Category)]
        public object vld1q_u8(object address) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(address, AdvSimd_LoadVector1281778);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> AdvSimd_LoadVector1281778 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.LoadVector128((byte*)arg0));
        /// <summary>
        /// float32x2_t vmax_f32 (float32x2_t a, float32x2_t b)
        ///A32: VMAX.F32 Dd, Dn, Dm
        ///A64: FMAX Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmax_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_f32", Category)]
        public object vmax_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// int16x4_t vmax_s16 (int16x4_t a, int16x4_t b)
        ///A32: VMAX.S16 Dd, Dn, Dm
        ///A64: SMAX Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmax_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_s16", Category)]
        public object vmax_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// int32x2_t vmax_s32 (int32x2_t a, int32x2_t b)
        ///A32: VMAX.S32 Dd, Dn, Dm
        ///A64: SMAX Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmax_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_s32", Category)]
        public object vmax_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// int8x8_t vmax_s8 (int8x8_t a, int8x8_t b)
        ///A32: VMAX.S8 Dd, Dn, Dm
        ///A64: SMAX Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmax_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_s8", Category)]
        public object vmax_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// uint16x4_t vmax_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VMAX.U16 Dd, Dn, Dm
        ///A64: UMAX Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmax_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_u16", Category)]
        public object vmax_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// uint32x2_t vmax_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VMAX.U32 Dd, Dn, Dm
        ///A64: UMAX Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmax_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_u32", Category)]
        public object vmax_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// uint8x8_t vmax_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VMAX.U8 Dd, Dn, Dm
        ///A64: UMAX Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmax_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_u8", Category)]
        public object vmax_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// float32x2_t vmaxnm_f32 (float32x2_t a, float32x2_t b)
        ///A32: VMAXNM.F32 Dd, Dn, Dm
        ///A64: FMAXNM Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmaxnm_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnm_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxnm_f32", Category)]
        public object vmaxnm_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxNumber);
        
        /// <summary>
        /// float64x1_t vmaxnm_f64 (float64x1_t a, float64x1_t b)
        ///A32: VMAXNM.F64 Dd, Dn, Dm
        ///A64: FMAXNM Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vmaxnm_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnm_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxnm_f64", Category)]
        public object vmaxnm_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxNumberScalar);
        
        /// <summary>
        /// float32x4_t vmaxnmq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VMAXNM.F32 Qd, Qn, Qm
        ///A64: FMAXNM Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmaxnmq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxnmq_f32", Category)]
        public object vmaxnmq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxNumber);
        
        /// <summary>
        /// float32_t vmaxnms_f32 (float32_t a, float32_t b)
        ///A32: VMAXNM.F32 Sd, Sn, Sm
        ///A64: FMAXNM Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vmaxnms_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnms_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxnms_f32", Category)]
        public object vmaxnms_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxNumberScalar);
        
        /// <summary>
        /// float32x4_t vmaxq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VMAX.F32 Qd, Qn, Qm
        ///A64: FMAX Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmaxq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_f32", Category)]
        public object vmaxq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// int16x8_t vmaxq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VMAX.S16 Qd, Qn, Qm
        ///A64: SMAX Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmaxq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_s16", Category)]
        public object vmaxq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// int32x4_t vmaxq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VMAX.S32 Qd, Qn, Qm
        ///A64: SMAX Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmaxq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_s32", Category)]
        public object vmaxq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// int8x16_t vmaxq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VMAX.S8 Qd, Qn, Qm
        ///A64: SMAX Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmaxq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_s8", Category)]
        public object vmaxq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// uint16x8_t vmaxq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VMAX.U16 Qd, Qn, Qm
        ///A64: UMAX Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmaxq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_u16", Category)]
        public object vmaxq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// uint32x4_t vmaxq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VMAX.U32 Qd, Qn, Qm
        ///A64: UMAX Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmaxq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_u32", Category)]
        public object vmaxq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// uint8x16_t vmaxq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VMAX.U8 Qd, Qn, Qm
        ///A64: UMAX Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmaxq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_u8", Category)]
        public object vmaxq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Max);
        
        /// <summary>
        /// float32x2_t vmin_f32 (float32x2_t a, float32x2_t b)
        ///A32: VMIN.F32 Dd, Dn, Dm
        ///A64: FMIN Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmin_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_f32", Category)]
        public object vmin_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int16x4_t vmin_s16 (int16x4_t a, int16x4_t b)
        ///A32: VMIN.S16 Dd, Dn, Dm
        ///A64: SMIN Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmin_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_s16", Category)]
        public object vmin_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int32x2_t vmin_s32 (int32x2_t a, int32x2_t b)
        ///A32: VMIN.S32 Dd, Dn, Dm
        ///A64: SMIN Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmin_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_s32", Category)]
        public object vmin_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int8x8_t vmin_s8 (int8x8_t a, int8x8_t b)
        ///A32: VMIN.S8 Dd, Dn, Dm
        ///A64: SMIN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmin_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_s8", Category)]
        public object vmin_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// uint16x4_t vmin_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VMIN.U16 Dd, Dn, Dm
        ///A64: UMIN Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmin_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_u16", Category)]
        public object vmin_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// uint32x2_t vmin_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VMIN.U32 Dd, Dn, Dm
        ///A64: UMIN Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmin_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_u32", Category)]
        public object vmin_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// uint8x8_t vmin_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VMIN.U8 Dd, Dn, Dm
        ///A64: UMIN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmin_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_u8", Category)]
        public object vmin_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// float32x2_t vminnm_f32 (float32x2_t a, float32x2_t b)
        ///A32: VMINNM.F32 Dd, Dn, Dm
        ///A64: FMINNM Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vminnm_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnm_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminnm_f32", Category)]
        public object vminnm_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinNumber);
        
        /// <summary>
        /// float64x1_t vminnm_f64 (float64x1_t a, float64x1_t b)
        ///A32: VMINNM.F64 Dd, Dn, Dm
        ///A64: FMINNM Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vminnm_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnm_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminnm_f64", Category)]
        public object vminnm_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinNumberScalar);
        
        /// <summary>
        /// float32x4_t vminnmq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VMINNM.F32 Qd, Qn, Qm
        ///A64: FMINNM Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vminnmq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminnmq_f32", Category)]
        public object vminnmq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinNumber);
        
        /// <summary>
        /// float32_t vminnms_f32 (float32_t a, float32_t b)
        ///A32: VMINNM.F32 Sd, Sn, Sm
        ///A64: FMINNM Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vminnms_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnms_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminnms_f32", Category)]
        public object vminnms_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinNumberScalar);
        
        /// <summary>
        /// float32x4_t vminq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VMIN.F32 Qd, Qn, Qm
        ///A64: FMIN Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vminq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_f32", Category)]
        public object vminq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int16x8_t vminq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VMIN.S16 Qd, Qn, Qm
        ///A64: SMIN Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vminq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_s16", Category)]
        public object vminq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int32x4_t vminq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VMIN.S32 Qd, Qn, Qm
        ///A64: SMIN Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vminq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_s32", Category)]
        public object vminq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int8x16_t vminq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VMIN.S8 Qd, Qn, Qm
        ///A64: SMIN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vminq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_s8", Category)]
        public object vminq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// uint16x8_t vminq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VMIN.U16 Qd, Qn, Qm
        ///A64: UMIN Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vminq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_u16", Category)]
        public object vminq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// uint32x4_t vminq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VMIN.U32 Qd, Qn, Qm
        ///A64: UMIN Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vminq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_u32", Category)]
        public object vminq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// uint8x16_t vminq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VMIN.U8 Qd, Qn, Qm
        ///A64: UMIN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vminq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_u8", Category)]
        public object vminq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Min);
        
        /// <summary>
        /// int16x4_t vmla_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane)
        ///A32: VMLA.I16 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_lane_s16", Category)]
        public object vmla_lane_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
        ///A32: VMLA.I32 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_lane_s32", Category)]
        public object vmla_lane_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
        ///A32: VMLA.I16 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_lane_u16", Category)]
        public object vmla_lane_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
        ///A32: VMLA.I32 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_lane_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_lane_u32", Category)]
        public object vmla_lane_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
        ///A32: VMLA.I16 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_laneq_s16", Category)]
        public object vmla_laneq_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
        ///A32: VMLA.I32 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_laneq_s32", Category)]
        public object vmla_laneq_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
        ///A32: VMLA.I16 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_laneq_u16", Category)]
        public object vmla_laneq_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
        ///A32: VMLA.I32 Dd, Dn, Dm[lane]
        ///A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmla_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_laneq_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmla_laneq_u32", Category)]
        public object vmla_laneq_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int16x4_t vmla_n_s16 (int16x4_t a, int16x4_t b, int16_t c)
        ///A32: VMLA.I16 Dd, Dn, Dm[0]
        ///A64: MLA Vd.4H, Vn.4H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmla_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_n_s16", Category)]
        public object vmla_n_s16(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// int32x2_t vmla_n_s32 (int32x2_t a, int32x2_t b, int32_t c)
        ///A32: VMLA.I32 Dd, Dn, Dm[0]
        ///A64: MLA Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmla_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_n_s32", Category)]
        public object vmla_n_s32(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// uint16x4_t vmla_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c)
        ///A32: VMLA.I16 Dd, Dn, Dm[0]
        ///A64: MLA Vd.4H, Vn.4H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmla_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_n_u16", Category)]
        public object vmla_n_u16(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// uint32x2_t vmla_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c)
        ///A32: VMLA.I32 Dd, Dn, Dm[0]
        ///A64: MLA Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmla_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_n_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_n_u32", Category)]
        public object vmla_n_u32(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// int16x4_t vmla_s16 (int16x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VMLA.I16 Dd, Dn, Dm
        ///A64: MLA Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmla_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_s16", Category)]
        public object vmla_s16(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// int32x2_t vmla_s32 (int32x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VMLA.I32 Dd, Dn, Dm
        ///A64: MLA Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmla_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_s32", Category)]
        public object vmla_s32(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// int8x8_t vmla_s8 (int8x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VMLA.I8 Dd, Dn, Dm
        ///A64: MLA Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmla_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_s8", Category)]
        public object vmla_s8(object addend, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// uint16x4_t vmla_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VMLA.I16 Dd, Dn, Dm
        ///A64: MLA Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmla_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_u16", Category)]
        public object vmla_u16(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// uint32x2_t vmla_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VMLA.I32 Dd, Dn, Dm
        ///A64: MLA Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmla_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_u32", Category)]
        public object vmla_u32(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// uint8x8_t vmla_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VMLA.I8 Dd, Dn, Dm
        ///A64: MLA Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmla_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmla_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmla_u8", Category)]
        public object vmla_u8(object addend, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
        ///A32: VMLAL.S16 Qd, Dn+1, Dm[lane]
        ///A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_lane_s16", Category)]
        public object vmlal_high_lane_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
        ///A32: VMLAL.S32 Qd, Dn+1, Dm[lane]
        ///A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_lane_s32", Category)]
        public object vmlal_high_lane_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane)
        ///A32: VMLAL.U16 Qd, Dn+1, Dm[lane]
        ///A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_lane_u16", Category)]
        public object vmlal_high_lane_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane)
        ///A32: VMLAL.U32 Qd, Dn+1, Dm[lane]
        ///A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_lane_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_lane_u32", Category)]
        public object vmlal_high_lane_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
        ///A32: VMLAL.S16 Qd, Dn+1, Dm[lane]
        ///A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_laneq_s16", Category)]
        public object vmlal_high_laneq_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
        ///A32: VMLAL.S32 Qd, Dn+1, Dm[lane]
        ///A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_laneq_s32", Category)]
        public object vmlal_high_laneq_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane)
        ///A32: VMLAL.U16 Qd, Dn+1, Dm[lane]
        ///A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_laneq_u16", Category)]
        public object vmlal_high_laneq_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane)
        ///A32: VMLAL.U32 Qd, Dn+1, Dm[lane]
        ///A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_high_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_laneq_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_high_laneq_u32", Category)]
        public object vmlal_high_laneq_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndAdd);
        
        /// <summary>
        /// int32x4_t vmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
        ///A32: VMLAL.S16 Qd, Dn+1, Dm+1
        ///A64: SMLAL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlal_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_high_s16", Category)]
        public object vmlal_high_s16(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndAdd);
        
        /// <summary>
        /// int64x2_t vmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
        ///A32: VMLAL.S32 Qd, Dn+1, Dm+1
        ///A64: SMLAL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlal_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_high_s32", Category)]
        public object vmlal_high_s32(object addend, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndAdd);
        
        /// <summary>
        /// int16x8_t vmlal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c)
        ///A32: VMLAL.S8 Qd, Dn+1, Dm+1
        ///A64: SMLAL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlal_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_high_s8", Category)]
        public object vmlal_high_s8(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndAdd);
        
        /// <summary>
        /// uint32x4_t vmlal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VMLAL.U16 Qd, Dn+1, Dm+1
        ///A64: UMLAL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlal_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_high_u16", Category)]
        public object vmlal_high_u16(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndAdd);
        
        /// <summary>
        /// uint64x2_t vmlal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VMLAL.U32 Qd, Dn+1, Dm+1
        ///A64: UMLAL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlal_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_high_u32", Category)]
        public object vmlal_high_u32(object addend, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndAdd);
        
        /// <summary>
        /// uint16x8_t vmlal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VMLAL.U8 Qd, Dn+1, Dm+1
        ///A64: UMLAL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlal_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_high_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_high_u8", Category)]
        public object vmlal_high_u8(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndAdd);
        
        /// <summary>
        /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
        ///A32: VMLAL.S16 Qd, Dn, Dm[lane]
        ///A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_lane_s16", Category)]
        public object vmlal_lane_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
        ///A32: VMLAL.S32 Qd, Dn, Dm[lane]
        ///A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_lane_s32", Category)]
        public object vmlal_lane_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
        ///A32: VMLAL.U16 Qd, Dn, Dm[lane]
        ///A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_lane_u16", Category)]
        public object vmlal_lane_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
        ///A32: VMLAL.U32 Qd, Dn, Dm[lane]
        ///A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_lane_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_lane_u32", Category)]
        public object vmlal_lane_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
        ///A32: VMLAL.S16 Qd, Dn, Dm[lane]
        ///A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_laneq_s16", Category)]
        public object vmlal_laneq_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
        ///A32: VMLAL.S32 Qd, Dn, Dm[lane]
        ///A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_laneq_s32", Category)]
        public object vmlal_laneq_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
        ///A32: VMLAL.U16 Qd, Dn, Dm[lane]
        ///A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_laneq_u16", Category)]
        public object vmlal_laneq_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
        ///A32: VMLAL.U32 Qd, Dn, Dm[lane]
        ///A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlal_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_laneq_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlal_laneq_u32", Category)]
        public object vmlal_laneq_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndAdd);
        
        /// <summary>
        /// int32x4_t vmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VMLAL.S16 Qd, Dn, Dm
        ///A64: SMLAL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmlal_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_s16", Category)]
        public object vmlal_s16(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndAdd);
        
        /// <summary>
        /// int64x2_t vmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VMLAL.S32 Qd, Dn, Dm
        ///A64: SMLAL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmlal_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_s32", Category)]
        public object vmlal_s32(object addend, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndAdd);
        
        /// <summary>
        /// int16x8_t vmlal_s8 (int16x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VMLAL.S8 Qd, Dn, Dm
        ///A64: SMLAL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmlal_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_s8", Category)]
        public object vmlal_s8(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndAdd);
        
        /// <summary>
        /// uint32x4_t vmlal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VMLAL.U16 Qd, Dn, Dm
        ///A64: UMLAL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmlal_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_u16", Category)]
        public object vmlal_u16(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndAdd);
        
        /// <summary>
        /// uint64x2_t vmlal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VMLAL.U32 Qd, Dn, Dm
        ///A64: UMLAL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmlal_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_u32", Category)]
        public object vmlal_u32(object addend, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndAdd);
        
        /// <summary>
        /// uint16x8_t vmlal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VMLAL.U8 Qd, Dn, Dm
        ///A64: UMLAL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmlal_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlal_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlal_u8", Category)]
        public object vmlal_u8(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndAdd);
        
        /// <summary>
        /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
        ///A32: VMLA.I16 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_lane_s16", Category)]
        public object vmlaq_lane_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
        ///A32: VMLA.I32 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_lane_s32", Category)]
        public object vmlaq_lane_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane)
        ///A32: VMLA.I16 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_lane_u16", Category)]
        public object vmlaq_lane_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane)
        ///A32: VMLA.I32 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_lane_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_lane_u32", Category)]
        public object vmlaq_lane_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
        ///A32: VMLA.I16 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_laneq_s16", Category)]
        public object vmlaq_laneq_s16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
        ///A32: VMLA.I32 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_laneq_s32", Category)]
        public object vmlaq_laneq_s32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane)
        ///A32: VMLA.I16 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_laneq_u16", Category)]
        public object vmlaq_laneq_u16(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane)
        ///A32: VMLA.I32 Qd, Qn, Dm[lane]
        ///A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlaq_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_laneq_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlaq_laneq_u32", Category)]
        public object vmlaq_laneq_u32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddBySelectedScalar);
        
        /// <summary>
        /// int16x8_t vmlaq_n_s16 (int16x8_t a, int16x8_t b, int16_t c)
        ///A32: VMLA.I16 Qd, Qn, Dm[0]
        ///A64: MLA Vd.8H, Vn.8H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmlaq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_n_s16", Category)]
        public object vmlaq_n_s16(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// int32x4_t vmlaq_n_s32 (int32x4_t a, int32x4_t b, int32_t c)
        ///A32: VMLA.I32 Qd, Qn, Dm[0]
        ///A64: MLA Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmlaq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_n_s32", Category)]
        public object vmlaq_n_s32(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// uint16x8_t vmlaq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c)
        ///A32: VMLA.I16 Qd, Qn, Dm[0]
        ///A64: MLA Vd.8H, Vn.8H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmlaq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_n_u16", Category)]
        public object vmlaq_n_u16(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// uint32x4_t vmlaq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c)
        ///A32: VMLA.I32 Qd, Qn, Dm[0]
        ///A64: MLA Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmlaq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_n_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_n_u32", Category)]
        public object vmlaq_n_u32(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAddByScalar);
        
        /// <summary>
        /// int16x8_t vmlaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
        ///A32: VMLA.I16 Qd, Qn, Qm
        ///A64: MLA Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlaq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_s16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_s16", Category)]
        public object vmlaq_s16(object addend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// int32x4_t vmlaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
        ///A32: VMLA.I32 Qd, Qn, Qm
        ///A64: MLA Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlaq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_s32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_s32", Category)]
        public object vmlaq_s32(object addend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// int8x16_t vmlaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
        ///A32: VMLA.I8 Qd, Qn, Qm
        ///A64: MLA Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlaq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_s8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_s8", Category)]
        public object vmlaq_s8(object addend, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// uint16x8_t vmlaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VMLA.I16 Qd, Qn, Qm
        ///A64: MLA Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlaq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_u16)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_u16", Category)]
        public object vmlaq_u16(object addend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// uint32x4_t vmlaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VMLA.I32 Qd, Qn, Qm
        ///A64: MLA Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlaq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_u32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_u32", Category)]
        public object vmlaq_u32(object addend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// uint8x16_t vmlaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VMLA.I8 Qd, Qn, Qm
        ///A64: MLA Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlaq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlaq_u8)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlaq_u8", Category)]
        public object vmlaq_u8(object addend, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyAdd);
        
        /// <summary>
        /// int16x4_t vmls_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane)
        ///A32: VMLS.I16 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_lane_s16", Category)]
        public object vmls_lane_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
        ///A32: VMLS.I32 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_lane_s32", Category)]
        public object vmls_lane_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
        ///A32: VMLS.I16 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_lane_u16", Category)]
        public object vmls_lane_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
        ///A32: VMLS.I32 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_lane_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_lane_u32", Category)]
        public object vmls_lane_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
        ///A32: VMLS.I16 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_laneq_s16", Category)]
        public object vmls_laneq_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
        ///A32: VMLS.I32 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_laneq_s32", Category)]
        public object vmls_laneq_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
        ///A32: VMLS.I16 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_laneq_u16", Category)]
        public object vmls_laneq_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
        ///A32: VMLS.I32 Dd, Dn, Dm[lane]
        ///A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmls_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_laneq_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmls_laneq_u32", Category)]
        public object vmls_laneq_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int16x4_t vmls_n_s16 (int16x4_t a, int16x4_t b, int16_t c)
        ///A32: VMLS.I16 Dd, Dn, Dm[0]
        ///A64: MLS Vd.4H, Vn.4H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmls_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_n_s16", Category)]
        public object vmls_n_s16(object minuend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// int32x2_t vmls_n_s32 (int32x2_t a, int32x2_t b, int32_t c)
        ///A32: VMLS.I32 Dd, Dn, Dm[0]
        ///A64: MLS Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmls_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_n_s32", Category)]
        public object vmls_n_s32(object minuend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// uint16x4_t vmls_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c)
        ///A32: VMLS.I16 Dd, Dn, Dm[0]
        ///A64: MLS Vd.4H, Vn.4H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmls_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_n_u16", Category)]
        public object vmls_n_u16(object minuend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// uint32x2_t vmls_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c)
        ///A32: VMLS.I32 Dd, Dn, Dm[0]
        ///A64: MLS Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmls_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_n_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_n_u32", Category)]
        public object vmls_n_u32(object minuend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// int16x4_t vmls_s16 (int16x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VMLS.I16 Dd, Dn, Dm
        ///A64: MLS Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmls_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_s16", Category)]
        public object vmls_s16(object minuend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// int32x2_t vmls_s32 (int32x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VMLS.I32 Dd, Dn, Dm
        ///A64: MLS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmls_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_s32", Category)]
        public object vmls_s32(object minuend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// int8x8_t vmls_s8 (int8x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VMLS.I8 Dd, Dn, Dm
        ///A64: MLS Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmls_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_s8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_s8", Category)]
        public object vmls_s8(object minuend, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// uint16x4_t vmls_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VMLS.I16 Dd, Dn, Dm
        ///A64: MLS Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmls_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_u16", Category)]
        public object vmls_u16(object minuend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// uint32x2_t vmls_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VMLS.I32 Dd, Dn, Dm
        ///A64: MLS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmls_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_u32", Category)]
        public object vmls_u32(object minuend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VMLS.I8 Dd, Dn, Dm
        ///A64: MLS Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmls_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmls_u8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmls_u8", Category)]
        public object vmls_u8(object minuend, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
        ///A32: VMLSL.S16 Qd, Dn+1, Dm[lane]
        ///A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_lane_s16", Category)]
        public object vmlsl_high_lane_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
        ///A32: VMLSL.S32 Qd, Dn+1, Dm[lane]
        ///A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_lane_s32", Category)]
        public object vmlsl_high_lane_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane)
        ///A32: VMLSL.U16 Qd, Dn+1, Dm[lane]
        ///A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_lane_u16", Category)]
        public object vmlsl_high_lane_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane)
        ///A32: VMLSL.U32 Qd, Dn+1, Dm[lane]
        ///A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_lane_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_lane_u32", Category)]
        public object vmlsl_high_lane_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
        ///A32: VMLSL.S16 Qd, Dn+1, Dm[lane]
        ///A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_laneq_s16", Category)]
        public object vmlsl_high_laneq_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
        ///A32: VMLSL.S32 Qd, Dn+1, Dm[lane]
        ///A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_laneq_s32", Category)]
        public object vmlsl_high_laneq_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane)
        ///A32: VMLSL.U16 Qd, Dn+1, Dm[lane]
        ///A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_laneq_u16", Category)]
        public object vmlsl_high_laneq_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane)
        ///A32: VMLSL.U32 Qd, Dn+1, Dm[lane]
        ///A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_laneq_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_high_laneq_u32", Category)]
        public object vmlsl_high_laneq_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpperAndSubtract);
        
        /// <summary>
        /// int32x4_t vmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
        ///A32: VMLSL.S16 Qd, Dn+1, Dm+1
        ///A64: SMLSL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_high_s16", Category)]
        public object vmlsl_high_s16(object minuend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndSubtract);
        
        /// <summary>
        /// int64x2_t vmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c)
        ///A32: VMLSL.S32 Qd, Dn+1, Dm+1
        ///A64: SMLSL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_high_s32", Category)]
        public object vmlsl_high_s32(object minuend, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndSubtract);
        
        /// <summary>
        /// int16x8_t vmlsl_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c)
        ///A32: VMLSL.S8 Qd, Dn+1, Dm+1
        ///A64: SMLSL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_s8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_high_s8", Category)]
        public object vmlsl_high_s8(object minuend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndSubtract);
        
        /// <summary>
        /// uint32x4_t vmlsl_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VMLSL.U16 Qd, Dn+1, Dm+1
        ///A64: UMLSL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_high_u16", Category)]
        public object vmlsl_high_u16(object minuend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndSubtract);
        
        /// <summary>
        /// uint64x2_t vmlsl_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VMLSL.U32 Qd, Dn+1, Dm+1
        ///A64: UMLSL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_high_u32", Category)]
        public object vmlsl_high_u32(object minuend, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndSubtract);
        
        /// <summary>
        /// uint16x8_t vmlsl_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VMLSL.U8 Qd, Dn+1, Dm+1
        ///A64: UMLSL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlsl_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_high_u8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_high_u8", Category)]
        public object vmlsl_high_u8(object minuend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpperAndSubtract);
        
        /// <summary>
        /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
        ///A32: VMLSL.S16 Qd, Dn, Dm[lane]
        ///A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_lane_s16", Category)]
        public object vmlsl_lane_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
        ///A32: VMLSL.S32 Qd, Dn, Dm[lane]
        ///A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_lane_s32", Category)]
        public object vmlsl_lane_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
        ///A32: VMLSL.U16 Qd, Dn, Dm[lane]
        ///A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_lane_u16", Category)]
        public object vmlsl_lane_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
        ///A32: VMLSL.U32 Qd, Dn, Dm[lane]
        ///A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_lane_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_lane_u32", Category)]
        public object vmlsl_lane_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
        ///A32: VMLSL.S16 Qd, Dn, Dm[lane]
        ///A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_laneq_s16", Category)]
        public object vmlsl_laneq_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
        ///A32: VMLSL.S32 Qd, Dn, Dm[lane]
        ///A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_laneq_s32", Category)]
        public object vmlsl_laneq_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
        ///A32: VMLSL.U16 Qd, Dn, Dm[lane]
        ///A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_laneq_u16", Category)]
        public object vmlsl_laneq_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
        ///A32: VMLSL.U32 Qd, Dn, Dm[lane]
        ///A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsl_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_laneq_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsl_laneq_u32", Category)]
        public object vmlsl_laneq_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLowerAndSubtract);
        
        /// <summary>
        /// int32x4_t vmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c)
        ///A32: VMLSL.S16 Qd, Dn, Dm
        ///A64: SMLSL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmlsl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_s16", Category)]
        public object vmlsl_s16(object minuend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndSubtract);
        
        /// <summary>
        /// int64x2_t vmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c)
        ///A32: VMLSL.S32 Qd, Dn, Dm
        ///A64: SMLSL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmlsl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_s32", Category)]
        public object vmlsl_s32(object minuend, object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndSubtract);
        
        /// <summary>
        /// int16x8_t vmlsl_s8 (int16x8_t a, int8x8_t b, int8x8_t c)
        ///A32: VMLSL.S8 Qd, Dn, Dm
        ///A64: SMLSL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmlsl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_s8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_s8", Category)]
        public object vmlsl_s8(object minuend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndSubtract);
        
        /// <summary>
        /// uint32x4_t vmlsl_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c)
        ///A32: VMLSL.U16 Qd, Dn, Dm
        ///A64: UMLSL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmlsl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_u16", Category)]
        public object vmlsl_u16(object minuend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndSubtract);
        
        /// <summary>
        /// uint64x2_t vmlsl_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c)
        ///A32: VMLSL.U32 Qd, Dn, Dm
        ///A64: UMLSL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmlsl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_u32", Category)]
        public object vmlsl_u32(object minuend, object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndSubtract);
        
        /// <summary>
        /// uint16x8_t vmlsl_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c)
        ///A32: VMLSL.U8 Qd, Dn, Dm
        ///A64: UMLSL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmlsl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsl_u8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsl_u8", Category)]
        public object vmlsl_u8(object minuend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLowerAndSubtract);
        
        /// <summary>
        /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
        ///A32: VMLS.I16 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_lane_s16", Category)]
        public object vmlsq_lane_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
        ///A32: VMLS.I32 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_lane_s32", Category)]
        public object vmlsq_lane_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane)
        ///A32: VMLS.I16 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_lane_u16", Category)]
        public object vmlsq_lane_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane)
        ///A32: VMLS.I32 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_lane_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_lane_u32", Category)]
        public object vmlsq_lane_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
        ///A32: VMLS.I16 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_laneq_s16", Category)]
        public object vmlsq_laneq_s16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
        ///A32: VMLS.I32 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_laneq_s32", Category)]
        public object vmlsq_laneq_s32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane)
        ///A32: VMLS.I16 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_laneq_u16", Category)]
        public object vmlsq_laneq_u16(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane)
        ///A32: VMLS.I32 Qd, Qn, Dm[lane]
        ///A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmlsq_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_laneq_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmlsq_laneq_u32", Category)]
        public object vmlsq_laneq_u32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// int16x8_t vmlsq_n_s16 (int16x8_t a, int16x8_t b, int16_t c)
        ///A32: VMLS.I16 Qd, Qn, Dm[0]
        ///A64: MLS Vd.8H, Vn.8H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmlsq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_n_s16", Category)]
        public object vmlsq_n_s16(object minuend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// int32x4_t vmlsq_n_s32 (int32x4_t a, int32x4_t b, int32_t c)
        ///A32: VMLS.I32 Qd, Qn, Dm[0]
        ///A64: MLS Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmlsq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_n_s32", Category)]
        public object vmlsq_n_s32(object minuend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// uint16x8_t vmlsq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c)
        ///A32: VMLS.I16 Qd, Qn, Dm[0]
        ///A64: MLS Vd.8H, Vn.8H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmlsq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_n_u16", Category)]
        public object vmlsq_n_u16(object minuend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// uint32x4_t vmlsq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c)
        ///A32: VMLS.I32 Qd, Qn, Dm[0]
        ///A64: MLS Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmlsq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_n_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_n_u32", Category)]
        public object vmlsq_n_u32(object minuend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtractByScalar);
        
        /// <summary>
        /// int16x8_t vmlsq_s16 (int16x8_t a, int16x8_t b, int16x8_t c)
        ///A32: VMLS.I16 Qd, Qn, Qm
        ///A64: MLS Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlsq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_s16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_s16", Category)]
        public object vmlsq_s16(object minuend, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// int32x4_t vmlsq_s32 (int32x4_t a, int32x4_t b, int32x4_t c)
        ///A32: VMLS.I32 Qd, Qn, Qm
        ///A64: MLS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlsq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_s32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_s32", Category)]
        public object vmlsq_s32(object minuend, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// int8x16_t vmlsq_s8 (int8x16_t a, int8x16_t b, int8x16_t c)
        ///A32: VMLS.I8 Qd, Qn, Qm
        ///A64: MLS Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlsq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_s8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_s8", Category)]
        public object vmlsq_s8(object minuend, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// uint16x8_t vmlsq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c)
        ///A32: VMLS.I16 Qd, Qn, Qm
        ///A64: MLS Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmlsq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_u16)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_u16", Category)]
        public object vmlsq_u16(object minuend, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// uint32x4_t vmlsq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c)
        ///A32: VMLS.I32 Qd, Qn, Qm
        ///A64: MLS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmlsq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_u32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_u32", Category)]
        public object vmlsq_u32(object minuend, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// uint8x16_t vmlsq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c)
        ///A32: VMLS.I8 Qd, Qn, Qm
        ///A64: MLS Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmlsq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmlsq_u8)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmlsq_u8", Category)]
        public object vmlsq_u8(object minuend, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplySubtract);
        
        /// <summary>
        /// int32x4_t vmovl_high_s16 (int16x8_t a)
        ///A32: VMOVL.S16 Qd, Dm+1
        ///A64: SXTL2 Vd.4S, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmovl_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_high_s16", Category)]
        public object vmovl_high_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SignExtendWideningUpper);
        
        /// <summary>
        /// int64x2_t vmovl_high_s32 (int32x4_t a)
        ///A32: VMOVL.S32 Qd, Dm+1
        ///A64: SXTL2 Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmovl_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_high_s32", Category)]
        public object vmovl_high_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SignExtendWideningUpper);
        
        /// <summary>
        /// int16x8_t vmovl_high_s8 (int8x16_t a)
        ///A32: VMOVL.S8 Qd, Dm+1
        ///A64: SXTL2 Vd.8H, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmovl_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_high_s8", Category)]
        public object vmovl_high_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SignExtendWideningUpper);
        
        /// <summary>
        /// uint32x4_t vmovl_high_u16 (uint16x8_t a)
        ///A32: VMOVL.U16 Qd, Dm+1
        ///A64: UXTL2 Vd.4S, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmovl_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_high_u16", Category)]
        public object vmovl_high_u16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ZeroExtendWideningUpper);
        
        /// <summary>
        /// uint64x2_t vmovl_high_u32 (uint32x4_t a)
        ///A32: VMOVL.U32 Qd, Dm+1
        ///A64: UXTL2 Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmovl_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_high_u32", Category)]
        public object vmovl_high_u32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ZeroExtendWideningUpper);
        
        /// <summary>
        /// uint16x8_t vmovl_high_u8 (uint8x16_t a)
        ///A32: VMOVL.U8 Qd, Dm+1
        ///A64: UXTL2 Vd.8H, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmovl_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_high_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_high_u8", Category)]
        public object vmovl_high_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ZeroExtendWideningUpper);
        
        /// <summary>
        /// int32x4_t vmovl_s16 (int16x4_t a)
        ///A32: VMOVL.S16 Qd, Dm
        ///A64: SXTL Vd.4S, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vmovl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_s16", Category)]
        public object vmovl_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SignExtendWideningLower);
        
        /// <summary>
        /// int64x2_t vmovl_s32 (int32x2_t a)
        ///A32: VMOVL.S32 Qd, Dm
        ///A64: SXTL Vd.2D, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vmovl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_s32", Category)]
        public object vmovl_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SignExtendWideningLower);
        
        /// <summary>
        /// int16x8_t vmovl_s8 (int8x8_t a)
        ///A32: VMOVL.S8 Qd, Dm
        ///A64: SXTL Vd.8H, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmovl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_s8", Category)]
        public object vmovl_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SignExtendWideningLower);
        
        /// <summary>
        /// uint32x4_t vmovl_u16 (uint16x4_t a)
        ///A32: VMOVL.U16 Qd, Dm
        ///A64: UXTL Vd.4S, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vmovl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_u16", Category)]
        public object vmovl_u16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ZeroExtendWideningLower);
        
        /// <summary>
        /// uint64x2_t vmovl_u32 (uint32x2_t a)
        ///A32: VMOVL.U32 Qd, Dm
        ///A64: UXTL Vd.2D, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vmovl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_u32", Category)]
        public object vmovl_u32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ZeroExtendWideningLower);
        
        /// <summary>
        /// uint16x8_t vmovl_u8 (uint8x8_t a)
        ///A32: VMOVL.U8 Qd, Dm
        ///A64: UXTL Vd.8H, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmovl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovl_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovl_u8", Category)]
        public object vmovl_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ZeroExtendWideningLower);
        
        /// <summary>
        /// int8x16_t vmovn_high_s16 (int8x8_t r, int16x8_t a)
        ///A32: VMOVN.I16 Dd+1, Qm
        ///A64: XTN2 Vd.16B, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmovn_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_high_s16", Category)]
        public object vmovn_high_s16(object lower, object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vmovn_high_s32 (int16x4_t r, int32x4_t a)
        ///A32: VMOVN.I32 Dd+1, Qm
        ///A64: XTN2 Vd.8H, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmovn_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_high_s32", Category)]
        public object vmovn_high_s32(object lower, object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vmovn_high_s64 (int32x2_t r, int64x2_t a)
        ///A32: VMOVN.I64 Dd+1, Qm
        ///A64: XTN2 Vd.4S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vmovn_high_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_high_s64", Category)]
        public object vmovn_high_s64(object lower, object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vmovn_high_u16 (uint8x8_t r, uint16x8_t a)
        ///A32: VMOVN.I16 Dd+1, Qm
        ///A64: XTN2 Vd.16B, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmovn_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_u16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_high_u16", Category)]
        public object vmovn_high_u16(object lower, object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vmovn_high_u32 (uint16x4_t r, uint32x4_t a)
        ///A32: VMOVN.I32 Dd+1, Qm
        ///A64: XTN2 Vd.8H, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmovn_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_u32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_high_u32", Category)]
        public object vmovn_high_u32(object lower, object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vmovn_high_u64 (uint32x2_t r, uint64x2_t a)
        ///A32: VMOVN.I64 Dd+1, Qm
        ///A64: XTN2 Vd.4S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vmovn_high_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_high_u64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_high_u64", Category)]
        public object vmovn_high_u64(object lower, object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vmovn_s16 (int16x8_t a)
        ///A32: VMOVN.I16 Dd, Qm
        ///A64: XTN Vd.8B, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmovn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_s16", Category)]
        public object vmovn_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingLower);
        
        /// <summary>
        /// int16x4_t vmovn_s32 (int32x4_t a)
        ///A32: VMOVN.I32 Dd, Qm
        ///A64: XTN Vd.4H, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmovn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_s32", Category)]
        public object vmovn_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingLower);
        
        /// <summary>
        /// int32x2_t vmovn_s64 (int64x2_t a)
        ///A32: VMOVN.I64 Dd, Qm
        ///A64: XTN Vd.2S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vmovn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_s64", Category)]
        public object vmovn_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vmovn_u16 (uint16x8_t a)
        ///A32: VMOVN.I16 Dd, Qm
        ///A64: XTN Vd.8B, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmovn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_u16", Category)]
        public object vmovn_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vmovn_u32 (uint32x4_t a)
        ///A32: VMOVN.I32 Dd, Qm
        ///A64: XTN Vd.4H, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmovn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_u32", Category)]
        public object vmovn_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vmovn_u64 (uint64x2_t a)
        ///A32: VMOVN.I64 Dd, Qm
        ///A64: XTN Vd.2S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vmovn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmovn_u64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmovn_u64", Category)]
        public object vmovn_u64(object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ExtractNarrowingLower);
        
        /// <summary>
        /// float32x2_t vmul_f32 (float32x2_t a, float32x2_t b)
        ///A32: VMUL.F32 Dd, Dn, Dm
        ///A64: FMUL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmul_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_f32", Category)]
        public object vmul_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// float64x1_t vmul_f64 (float64x1_t a, float64x1_t b)
        ///A32: VMUL.F64 Dd, Dn, Dm
        ///A64: FMUL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vmul_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_f64", Category)]
        public object vmul_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyScalar);
        
        /// <summary>
        /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane)
        ///A32: VMUL.F32 Dd, Dn, Dm[lane]
        ///A64: FMUL Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_lane_f32", Category)]
        public object vmul_lane_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int16x4_t vmul_lane_s16 (int16x4_t a, int16x4_t v, const int lane)
        ///A32: VMUL.I16 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_lane_s16", Category)]
        public object vmul_lane_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
        ///A32: VMUL.I32 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_lane_s32", Category)]
        public object vmul_lane_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane)
        ///A32: VMUL.I16 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_lane_u16", Category)]
        public object vmul_lane_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane)
        ///A32: VMUL.I32 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_lane_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_lane_u32", Category)]
        public object vmul_lane_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane)
        ///A32: VMUL.F32 Dd, Dn, Dm[lane]
        ///A64: FMUL Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_laneq_f32", Category)]
        public object vmul_laneq_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
        ///A32: VMUL.I16 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_laneq_s16", Category)]
        public object vmul_laneq_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
        ///A32: VMUL.I32 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_laneq_s32", Category)]
        public object vmul_laneq_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane)
        ///A32: VMUL.I16 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_laneq_u16", Category)]
        public object vmul_laneq_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane)
        ///A32: VMUL.I32 Dd, Dn, Dm[lane]
        ///A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmul_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_laneq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmul_laneq_u32", Category)]
        public object vmul_laneq_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vmul_n_f32 (float32x2_t a, float32_t b)
        ///A32: VMUL.F32 Dd, Dn, Dm[0]
        ///A64: FMUL Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmul_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_n_f32", Category)]
        public object vmul_n_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b)
        ///A32: VMUL.I16 Dd, Dn, Dm[0]
        ///A64: MUL Vd.4H, Vn.4H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmul_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_n_s16", Category)]
        public object vmul_n_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// int32x2_t vmul_n_s32 (int32x2_t a, int32_t b)
        ///A32: VMUL.I32 Dd, Dn, Dm[0]
        ///A64: MUL Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmul_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_n_s32", Category)]
        public object vmul_n_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// uint16x4_t vmul_n_u16 (uint16x4_t a, uint16_t b)
        ///A32: VMUL.I16 Dd, Dn, Dm[0]
        ///A64: MUL Vd.4H, Vn.4H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmul_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_n_u16", Category)]
        public object vmul_n_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// uint32x2_t vmul_n_u32 (uint32x2_t a, uint32_t b)
        ///A32: VMUL.I32 Dd, Dn, Dm[0]
        ///A64: MUL Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmul_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_n_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_n_u32", Category)]
        public object vmul_n_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b)
        ///A32: VMUL.P8 Dd, Dn, Dm
        ///A64: PMUL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmul_p8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_p8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_p8", Category)]
        public object vmul_p8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.PolynomialMultiply);
        
        /// <summary>
        /// int16x4_t vmul_s16 (int16x4_t a, int16x4_t b)
        ///A32: VMUL.I16 Dd, Dn, Dm
        ///A64: MUL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmul_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_s16", Category)]
        public object vmul_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// int32x2_t vmul_s32 (int32x2_t a, int32x2_t b)
        ///A32: VMUL.I32 Dd, Dn, Dm
        ///A64: MUL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmul_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_s32", Category)]
        public object vmul_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// int8x8_t vmul_s8 (int8x8_t a, int8x8_t b)
        ///A32: VMUL.I8 Dd, Dn, Dm
        ///A64: MUL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmul_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_s8", Category)]
        public object vmul_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// uint16x4_t vmul_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VMUL.I16 Dd, Dn, Dm
        ///A64: MUL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmul_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_u16", Category)]
        public object vmul_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// uint32x2_t vmul_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VMUL.I32 Dd, Dn, Dm
        ///A64: MUL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmul_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_u32", Category)]
        public object vmul_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// uint8x8_t vmul_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VMUL.I8 Dd, Dn, Dm
        ///A64: MUL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmul_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmul_u8", Category)]
        public object vmul_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
        ///A32: VMULL.S16 Qd, Dn+1, Dm[lane]
        ///A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_lane_s16", Category)]
        public object vmull_high_lane_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
        ///A32: VMULL.S32 Qd, Dn+1, Dm[lane]
        ///A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_lane_s32", Category)]
        public object vmull_high_lane_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane)
        ///A32: VMULL.U16 Qd, Dn+1, Dm[lane]
        ///A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_lane_u16", Category)]
        public object vmull_high_lane_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane)
        ///A32: VMULL.U32 Qd, Dn+1, Dm[lane]
        ///A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_lane_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_lane_u32", Category)]
        public object vmull_high_lane_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
        ///A32: VMULL.S16 Qd, Dn+1, Dm[lane]
        ///A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_laneq_s16", Category)]
        public object vmull_high_laneq_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
        ///A32: VMULL.S32 Qd, Dn+1, Dm[lane]
        ///A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_laneq_s32", Category)]
        public object vmull_high_laneq_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane)
        ///A32: VMULL.U16 Qd, Dn+1, Dm[lane]
        ///A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_laneq_u16", Category)]
        public object vmull_high_laneq_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane)
        ///A32: VMULL.U32 Qd, Dn+1, Dm[lane]
        ///A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_high_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_laneq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_high_laneq_u32", Category)]
        public object vmull_high_laneq_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningUpper);
        
        /// <summary>
        /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b)
        ///A32: VMULL.P8 Qd, Dn+1, Dm+1
        ///A64: PMULL2 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmull_high_p8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_p8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_p8", Category)]
        public object vmull_high_p8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.PolynomialMultiplyWideningUpper);
        
        /// <summary>
        /// int32x4_t vmull_high_s16 (int16x8_t a, int16x8_t b)
        ///A32: VMULL.S16 Qd, Dn+1, Dm+1
        ///A64: SMULL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmull_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_s16", Category)]
        public object vmull_high_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpper);
        
        /// <summary>
        /// int64x2_t vmull_high_s32 (int32x4_t a, int32x4_t b)
        ///A32: VMULL.S32 Qd, Dn+1, Dm+1
        ///A64: SMULL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmull_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_s32", Category)]
        public object vmull_high_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpper);
        
        /// <summary>
        /// int16x8_t vmull_high_s8 (int8x16_t a, int8x16_t b)
        ///A32: VMULL.S8 Qd, Dn+1, Dm+1
        ///A64: SMULL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmull_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_s8", Category)]
        public object vmull_high_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpper);
        
        /// <summary>
        /// uint32x4_t vmull_high_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VMULL.U16 Qd, Dn+1, Dm+1
        ///A64: UMULL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmull_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_u16", Category)]
        public object vmull_high_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpper);
        
        /// <summary>
        /// uint64x2_t vmull_high_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VMULL.U32 Qd, Dn+1, Dm+1
        ///A64: UMULL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmull_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_u32", Category)]
        public object vmull_high_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpper);
        
        /// <summary>
        /// uint16x8_t vmull_high_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VMULL.U8 Qd, Dn+1, Dm+1
        ///A64: UMULL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmull_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_u8", Category)]
        public object vmull_high_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningUpper);
        
        /// <summary>
        /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane)
        ///A32: VMULL.S16 Qd, Dn, Dm[lane]
        ///A64: SMULL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_lane_s16", Category)]
        public object vmull_lane_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
        ///A32: VMULL.S32 Qd, Dn, Dm[lane]
        ///A64: SMULL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_lane_s32", Category)]
        public object vmull_lane_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane)
        ///A32: VMULL.U16 Qd, Dn, Dm[lane]
        ///A64: UMULL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_lane_u16", Category)]
        public object vmull_lane_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane)
        ///A32: VMULL.U32 Qd, Dn, Dm[lane]
        ///A64: UMULL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_lane_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_lane_u32", Category)]
        public object vmull_lane_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
        ///A32: VMULL.S16 Qd, Dn, Dm[lane]
        ///A64: SMULL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_laneq_s16", Category)]
        public object vmull_laneq_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
        ///A32: VMULL.S32 Qd, Dn, Dm[lane]
        ///A64: SMULL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_laneq_s32", Category)]
        public object vmull_laneq_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane)
        ///A32: VMULL.U16 Qd, Dn, Dm[lane]
        ///A64: UMULL Vd.4S, Vn.4H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_laneq_u16", Category)]
        public object vmull_laneq_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane)
        ///A32: VMULL.U32 Qd, Dn, Dm[lane]
        ///A64: UMULL Vd.2D, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmull_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_laneq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmull_laneq_u32", Category)]
        public object vmull_laneq_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalarWideningLower);
        
        /// <summary>
        /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b)
        ///A32: VMULL.P8 Qd, Dn, Dm
        ///A64: PMULL Vd.16B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmull_p8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_p8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_p8", Category)]
        public object vmull_p8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.PolynomialMultiplyWideningLower);
        
        /// <summary>
        /// int32x4_t vmull_s16 (int16x4_t a, int16x4_t b)
        ///A32: VMULL.S16 Qd, Dn, Dm
        ///A64: SMULL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmull_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_s16", Category)]
        public object vmull_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLower);
        
        /// <summary>
        /// int64x2_t vmull_s32 (int32x2_t a, int32x2_t b)
        ///A32: VMULL.S32 Qd, Dn, Dm
        ///A64: SMULL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmull_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_s32", Category)]
        public object vmull_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLower);
        
        /// <summary>
        /// int16x8_t vmull_s8 (int8x8_t a, int8x8_t b)
        ///A32: VMULL.S8 Qd, Dn, Dm
        ///A64: SMULL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmull_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_s8", Category)]
        public object vmull_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLower);
        
        /// <summary>
        /// uint32x4_t vmull_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VMULL.U16 Qd, Dn, Dm
        ///A64: UMULL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vmull_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_u16", Category)]
        public object vmull_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLower);
        
        /// <summary>
        /// uint64x2_t vmull_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VMULL.U32 Qd, Dn, Dm
        ///A64: UMULL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmull_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_u32", Category)]
        public object vmull_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLower);
        
        /// <summary>
        /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VMULL.U8 Qd, Dn, Dm
        ///A64: UMULL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vmull_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_u8", Category)]
        public object vmull_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyWideningLower);
        
        /// <summary>
        /// float32x4_t vmulq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VMUL.F32 Qd, Qn, Qm
        ///A64: FMUL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmulq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_f32", Category)]
        public object vmulq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane)
        ///A32: VMUL.F32 Qd, Qn, Dm[lane]
        ///A64: FMUL Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_lane_f32", Category)]
        public object vmulq_lane_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
        ///A32: VMUL.I16 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_lane_s16", Category)]
        public object vmulq_lane_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
        ///A32: VMUL.I32 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_lane_s32", Category)]
        public object vmulq_lane_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane)
        ///A32: VMUL.I16 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_lane_u16", Category)]
        public object vmulq_lane_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane)
        ///A32: VMUL.I32 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_lane_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_lane_u32", Category)]
        public object vmulq_lane_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane)
        ///A32: VMUL.F32 Qd, Qn, Dm[lane]
        ///A64: FMUL Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_laneq_f32", Category)]
        public object vmulq_laneq_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
        ///A32: VMUL.I16 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_laneq_s16", Category)]
        public object vmulq_laneq_s16(object left, object right, byte rightIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
        ///A32: VMUL.I32 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_laneq_s32", Category)]
        public object vmulq_laneq_s32(object left, object right, byte rightIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane)
        ///A32: VMUL.I16 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_laneq_u16", Category)]
        public object vmulq_laneq_u16(object left, object right, byte rightIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane)
        ///A32: VMUL.I32 Qd, Qn, Dm[lane]
        ///A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_laneq_u32", Category)]
        public object vmulq_laneq_u32(object left, object right, byte rightIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vmulq_n_f32 (float32x4_t a, float32_t b)
        ///A32: VMUL.F32 Qd, Qn, Dm[0]
        ///A64: FMUL Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmulq_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_n_f32", Category)]
        public object vmulq_n_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// int16x8_t vmulq_n_s16 (int16x8_t a, int16_t b)
        ///A32: VMUL.I16 Qd, Qn, Dm[0]
        ///A64: MUL Vd.8H, Vn.8H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmulq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_n_s16", Category)]
        public object vmulq_n_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// int32x4_t vmulq_n_s32 (int32x4_t a, int32_t b)
        ///A32: VMUL.I32 Qd, Qn, Dm[0]
        ///A64: MUL Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmulq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_n_s32", Category)]
        public object vmulq_n_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// uint16x8_t vmulq_n_u16 (uint16x8_t a, uint16_t b)
        ///A32: VMUL.I16 Qd, Qn, Dm[0]
        ///A64: MUL Vd.8H, Vn.8H, Vm.H[0]
        ///
        ///
        ///Instruction Documentation: [vmulq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_n_u16", Category)]
        public object vmulq_n_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// uint32x4_t vmulq_n_u32 (uint32x4_t a, uint32_t b)
        ///A32: VMUL.I32 Qd, Qn, Dm[0]
        ///A64: MUL Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vmulq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_n_u32", Category)]
        public object vmulq_n_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyByScalar);
        
        /// <summary>
        /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b)
        ///A32: VMUL.P8 Qd, Qn, Qm
        ///A64: PMUL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmulq_p8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_p8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_p8", Category)]
        public object vmulq_p8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.PolynomialMultiply);
        
        /// <summary>
        /// int16x8_t vmulq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VMUL.I16 Qd, Qn, Qm
        ///A64: MUL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmulq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_s16", Category)]
        public object vmulq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// int32x4_t vmulq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VMUL.I32 Qd, Qn, Qm
        ///A64: MUL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmulq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_s32", Category)]
        public object vmulq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// int8x16_t vmulq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VMUL.I8 Qd, Qn, Qm
        ///A64: MUL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmulq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_s8", Category)]
        public object vmulq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// uint16x8_t vmulq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VMUL.I16 Qd, Qn, Qm
        ///A64: MUL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vmulq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_u16", Category)]
        public object vmulq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// uint32x4_t vmulq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VMUL.I32 Qd, Qn, Qm
        ///A64: MUL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmulq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_u32", Category)]
        public object vmulq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// uint8x16_t vmulq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VMUL.I8 Qd, Qn, Qm
        ///A64: MUL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vmulq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_u8", Category)]
        public object vmulq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Multiply);
        
        /// <summary>
        /// float32_t vmuls_f32 (float32_t a, float32_t b)
        ///A32: VMUL.F32 Sd, Sn, Sm
        ///A64: FMUL Sd, Sn, Sm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmuls_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuls_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmuls_f32", Category)]
        public object vmuls_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyScalar);
        
        /// <summary>
        /// float32_t vmuls_lane_f32 (float32_t a, float32x2_t v, const int lane)
        ///A32: VMUL.F32 Sd, Sn, Dm[lane]
        ///A64: FMUL Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmuls_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuls_lane_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmuls_lane_f32", Category)]
        public object vmuls_lane_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyScalarBySelectedScalar);
        
        /// <summary>
        /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane)
        ///A32: VMUL.F32 Sd, Sn, Dm[lane]
        ///A64: FMUL Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmuls_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuls_laneq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmuls_laneq_f32", Category)]
        public object vmuls_laneq_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.MultiplyScalarBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vmvn_f32 (float32x2_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmvn_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_f32", Category)]
        public object vmvn_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// float64x1_t vmvn_f64 (float64x1_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmvn_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_f64", Category)]
        public object vmvn_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int16x4_t vmvn_s16 (int16x4_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_s16", Category)]
        public object vmvn_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int32x2_t vmvn_s32 (int32x2_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_s32", Category)]
        public object vmvn_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int64x1_t vmvn_s64 (int64x1_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_s64", Category)]
        public object vmvn_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int8x8_t vmvn_s8 (int8x8_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_s8", Category)]
        public object vmvn_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint16x4_t vmvn_u16 (uint16x4_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_u16", Category)]
        public object vmvn_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint32x2_t vmvn_u32 (uint32x2_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_u32", Category)]
        public object vmvn_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint64x1_t vmvn_u64 (uint64x1_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_u64", Category)]
        public object vmvn_u64(object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint8x8_t vmvn_u8 (uint8x8_t a)
        ///A32: VMVN Dd, Dm
        ///A64: MVN Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmvn_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvn_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvn_u8", Category)]
        public object vmvn_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// float32x4_t vmvnq_f32 (float32x4_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmvnq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_f32", Category)]
        public object vmvnq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// float64x2_t vmvnq_f64 (float64x2_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmvnq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_f64", Category)]
        public object vmvnq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int16x8_t vmvnq_s16 (int16x8_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_s16", Category)]
        public object vmvnq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int32x4_t vmvnq_s32 (int32x4_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_s32", Category)]
        public object vmvnq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int64x2_t vmvnq_s64 (int64x2_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_s64", Category)]
        public object vmvnq_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// int8x16_t vmvnq_s8 (int8x16_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_s8", Category)]
        public object vmvnq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint16x8_t vmvnq_u16 (uint16x8_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_u16", Category)]
        public object vmvnq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint32x4_t vmvnq_u32 (uint32x4_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_u32", Category)]
        public object vmvnq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint64x2_t vmvnq_u64 (uint64x2_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_u64", Category)]
        public object vmvnq_u64(object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// uint8x16_t vmvnq_u8 (uint8x16_t a)
        ///A32: VMVN Qd, Qm
        ///A64: MVN Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmvnq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmvnq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmvnq_u8", Category)]
        public object vmvnq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Not);
        
        /// <summary>
        /// float32x2_t vneg_f32 (float32x2_t a)
        ///A32: VNEG.F32 Dd, Dm
        ///A64: FNEG Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vneg_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vneg_f32", Category)]
        public object vneg_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// float64x1_t vneg_f64 (float64x1_t a)
        ///A32: VNEG.F64 Dd, Dm
        ///A64: FNEG Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vneg_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vneg_f64", Category)]
        public object vneg_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateScalar);
        
        /// <summary>
        /// int16x4_t vneg_s16 (int16x4_t a)
        ///A32: VNEG.S16 Dd, Dm
        ///A64: NEG Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vneg_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vneg_s16", Category)]
        public object vneg_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// int32x2_t vneg_s32 (int32x2_t a)
        ///A32: VNEG.S32 Dd, Dm
        ///A64: NEG Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vneg_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vneg_s32", Category)]
        public object vneg_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// int8x8_t vneg_s8 (int8x8_t a)
        ///A32: VNEG.S8 Dd, Dm
        ///A64: NEG Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vneg_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vneg_s8", Category)]
        public object vneg_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// float32x4_t vnegq_f32 (float32x4_t a)
        ///A32: VNEG.F32 Qd, Qm
        ///A64: FNEG Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vnegq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegq_f32", Category)]
        public object vnegq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// int16x8_t vnegq_s16 (int16x8_t a)
        ///A32: VNEG.S16 Qd, Qm
        ///A64: NEG Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vnegq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegq_s16", Category)]
        public object vnegq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// int32x4_t vnegq_s32 (int32x4_t a)
        ///A32: VNEG.S32 Qd, Qm
        ///A64: NEG Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vnegq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegq_s32", Category)]
        public object vnegq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// int8x16_t vnegq_s8 (int8x16_t a)
        ///A32: VNEG.S8 Qd, Qm
        ///A64: NEG Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vnegq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegq_s8", Category)]
        public object vnegq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Negate);
        
        /// <summary>
        /// float32_t vnegs_f32 (float32_t a)
        ///A32: VNEG.F32 Sd, Sm
        ///A64: FNEG Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vnegs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegs_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegs_f32", Category)]
        public object vnegs_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateScalar);
        
        /// <summary>
        /// float32x2_t vorn_f32 (float32x2_t a, float32x2_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vorn_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_f32", Category)]
        public object vorn_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// float64x1_t vorn_f64 (float64x1_t a, float64x1_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vorn_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_f64", Category)]
        public object vorn_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int16x4_t vorn_s16 (int16x4_t a, int16x4_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_s16", Category)]
        public object vorn_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int32x2_t vorn_s32 (int32x2_t a, int32x2_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_s32", Category)]
        public object vorn_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int64x1_t vorn_s64 (int64x1_t a, int64x1_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_s64", Category)]
        public object vorn_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int8x8_t vorn_s8 (int8x8_t a, int8x8_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_s8", Category)]
        public object vorn_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint16x4_t vorn_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_u16", Category)]
        public object vorn_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint32x2_t vorn_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_u32", Category)]
        public object vorn_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint64x1_t vorn_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_u64", Category)]
        public object vorn_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint8x8_t vorn_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VORN Dd, Dn, Dm
        ///A64: ORN Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorn_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorn_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorn_u8", Category)]
        public object vorn_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// float32x4_t vornq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vornq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_f32", Category)]
        public object vornq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// float64x2_t vornq_f64 (float64x2_t a, float64x2_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vornq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_f64", Category)]
        public object vornq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int16x8_t vornq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_s16", Category)]
        public object vornq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int32x4_t vornq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_s32", Category)]
        public object vornq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int64x2_t vornq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_s64", Category)]
        public object vornq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// int8x16_t vornq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_s8", Category)]
        public object vornq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint16x8_t vornq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_u16", Category)]
        public object vornq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint32x4_t vornq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_u32", Category)]
        public object vornq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint64x2_t vornq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_u64", Category)]
        public object vornq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// uint8x16_t vornq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VORN Qd, Qn, Qm
        ///A64: ORN Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vornq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vornq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vornq_u8", Category)]
        public object vornq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.OrNot);
        
        /// <summary>
        /// float32x2_t vorr_f32 (float32x2_t a, float32x2_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vorr_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_f32", Category)]
        public object vorr_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// float64x1_t vorr_f64 (float64x1_t a, float64x1_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vorr_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_f64", Category)]
        public object vorr_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int16x4_t vorr_s16 (int16x4_t a, int16x4_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_s16", Category)]
        public object vorr_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int32x2_t vorr_s32 (int32x2_t a, int32x2_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_s32", Category)]
        public object vorr_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int64x1_t vorr_s64 (int64x1_t a, int64x1_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_s64", Category)]
        public object vorr_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int8x8_t vorr_s8 (int8x8_t a, int8x8_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_s8", Category)]
        public object vorr_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint16x4_t vorr_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_u16", Category)]
        public object vorr_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint32x2_t vorr_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_u32", Category)]
        public object vorr_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint64x1_t vorr_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_u64", Category)]
        public object vorr_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint8x8_t vorr_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VORR Dd, Dn, Dm
        ///A64: ORR Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vorr_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorr_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorr_u8", Category)]
        public object vorr_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// float32x4_t vorrq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vorrq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_f32", Category)]
        public object vorrq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// float64x2_t vorrq_f64 (float64x2_t a, float64x2_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vorrq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_f64", Category)]
        public object vorrq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int16x8_t vorrq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_s16", Category)]
        public object vorrq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int32x4_t vorrq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_s32", Category)]
        public object vorrq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int64x2_t vorrq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_s64", Category)]
        public object vorrq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int8x16_t vorrq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_s8", Category)]
        public object vorrq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint16x8_t vorrq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_u16", Category)]
        public object vorrq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint32x4_t vorrq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_u32", Category)]
        public object vorrq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint64x2_t vorrq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_u64", Category)]
        public object vorrq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// uint8x16_t vorrq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VORR Qd, Qn, Qm
        ///A64: ORR Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vorrq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vorrq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vorrq_u8", Category)]
        public object vorrq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Or);
        
        /// <summary>
        /// int32x2_t vpadal_s16 (int32x2_t a, int16x4_t b)
        ///A32: VPADAL.S16 Dd, Dm
        ///A64: SADALP Vd.2S, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vpadal_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_s16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadal_s16", Category)]
        public object vpadal_s16(object addend, object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector64<int>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// int64x1_t vpadal_s32 (int64x1_t a, int32x2_t b)
        ///A32: VPADAL.S32 Dd, Dm
        ///A64: SADALP Vd.1D, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpadal_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_s32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadal_s32", Category)]
        public object vpadal_s32(object addend, object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector64<long>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAddScalar);
        
        /// <summary>
        /// int16x4_t vpadal_s8 (int16x4_t a, int8x8_t b)
        ///A32: VPADAL.S8 Dd, Dm
        ///A64: SADALP Vd.4H, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vpadal_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_s8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadal_s8", Category)]
        public object vpadal_s8(object addend, object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector64<short>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// uint32x2_t vpadal_u16 (uint32x2_t a, uint16x4_t b)
        ///A32: VPADAL.U16 Dd, Dm
        ///A64: UADALP Vd.2S, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vpadal_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_u16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadal_u16", Category)]
        public object vpadal_u16(object addend, object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector64<uint>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// uint64x1_t vpadal_u32 (uint64x1_t a, uint32x2_t b)
        ///A32: VPADAL.U32 Dd, Dm
        ///A64: UADALP Vd.1D, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpadal_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_u32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadal_u32", Category)]
        public object vpadal_u32(object addend, object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAddScalar);
        
        /// <summary>
        /// uint16x4_t vpadal_u8 (uint16x4_t a, uint8x8_t b)
        ///A32: VPADAL.U8 Dd, Dm
        ///A64: UADALP Vd.4H, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vpadal_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadal_u8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadal_u8", Category)]
        public object vpadal_u8(object addend, object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// int32x4_t vpadalq_s16 (int32x4_t a, int16x8_t b)
        ///A32: VPADAL.S16 Qd, Qm
        ///A64: SADALP Vd.4S, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vpadalq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_s16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadalq_s16", Category)]
        public object vpadalq_s16(object addend, object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// int64x2_t vpadalq_s32 (int64x2_t a, int32x4_t b)
        ///A32: VPADAL.S32 Qd, Qm
        ///A64: SADALP Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vpadalq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_s32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadalq_s32", Category)]
        public object vpadalq_s32(object addend, object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// int16x8_t vpadalq_s8 (int16x8_t a, int8x16_t b)
        ///A32: VPADAL.S8 Qd, Qm
        ///A64: SADALP Vd.8H, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vpadalq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_s8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadalq_s8", Category)]
        public object vpadalq_s8(object addend, object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// uint32x4_t vpadalq_u16 (uint32x4_t a, uint16x8_t b)
        ///A32: VPADAL.U16 Qd, Qm
        ///A64: UADALP Vd.4S, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vpadalq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_u16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadalq_u16", Category)]
        public object vpadalq_u16(object addend, object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// uint64x2_t vpadalq_u32 (uint64x2_t a, uint32x4_t b)
        ///A32: VPADAL.U32 Qd, Qm
        ///A64: UADALP Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vpadalq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_u32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadalq_u32", Category)]
        public object vpadalq_u32(object addend, object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// uint16x8_t vpadalq_u8 (uint16x8_t a, uint8x16_t b)
        ///A32: VPADAL.U8 Qd, Qm
        ///A64: UADALP Vd.8H, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vpadalq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadalq_u8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadalq_u8", Category)]
        public object vpadalq_u8(object addend, object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(addend, value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningAndAdd);
        
        /// <summary>
        /// float32x2_t vpadd_f32 (float32x2_t a, float32x2_t b)
        ///A32: VPADD.F32 Dd, Dn, Dm
        ///A64: FADDP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpadd_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_f32", Category)]
        public object vpadd_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// int16x4_t vpadd_s16 (int16x4_t a, int16x4_t b)
        ///A32: VPADD.I16 Dd, Dn, Dm
        ///A64: ADDP Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vpadd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_s16", Category)]
        public object vpadd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// int32x2_t vpadd_s32 (int32x2_t a, int32x2_t b)
        ///A32: VPADD.I32 Dd, Dn, Dm
        ///A64: ADDP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpadd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_s32", Category)]
        public object vpadd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// int8x8_t vpadd_s8 (int8x8_t a, int8x8_t b)
        ///A32: VPADD.I8 Dd, Dn, Dm
        ///A64: ADDP Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vpadd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_s8", Category)]
        public object vpadd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// uint16x4_t vpadd_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VPADD.I16 Dd, Dn, Dm
        ///A64: ADDP Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vpadd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_u16", Category)]
        public object vpadd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// uint32x2_t vpadd_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VPADD.I32 Dd, Dn, Dm
        ///A64: ADDP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpadd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_u32", Category)]
        public object vpadd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VPADD.I8 Dd, Dn, Dm
        ///A64: ADDP Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vpadd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpadd_u8", Category)]
        public object vpadd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwise);
        
        /// <summary>
        /// int32x2_t vpaddl_s16 (int16x4_t a)
        ///A32: VPADDL.S16 Dd, Dm
        ///A64: SADDLP Vd.2S, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vpaddl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddl_s16", Category)]
        public object vpaddl_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// int64x1_t vpaddl_s32 (int32x2_t a)
        ///A32: VPADDL.S32 Dd, Dm
        ///A64: SADDLP Dd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpaddl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddl_s32", Category)]
        public object vpaddl_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningScalar);
        
        /// <summary>
        /// int16x4_t vpaddl_s8 (int8x8_t a)
        ///A32: VPADDL.S8 Dd, Dm
        ///A64: SADDLP Vd.4H, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vpaddl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddl_s8", Category)]
        public object vpaddl_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// uint32x2_t vpaddl_u16 (uint16x4_t a)
        ///A32: VPADDL.U16 Dd, Dm
        ///A64: UADDLP Vd.2S, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vpaddl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddl_u16", Category)]
        public object vpaddl_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// uint64x1_t vpaddl_u32 (uint32x2_t a)
        ///A32: VPADDL.U32 Dd, Dm
        ///A64: UADDLP Dd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpaddl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddl_u32", Category)]
        public object vpaddl_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWideningScalar);
        
        /// <summary>
        /// uint16x4_t vpaddl_u8 (uint8x8_t a)
        ///A32: VPADDL.U8 Dd, Dm
        ///A64: UADDLP Vd.4H, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vpaddl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddl_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddl_u8", Category)]
        public object vpaddl_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// int32x4_t vpaddlq_s16 (int16x8_t a)
        ///A32: VPADDL.S16 Qd, Qm
        ///A64: SADDLP Vd.4S, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vpaddlq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddlq_s16", Category)]
        public object vpaddlq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// int64x2_t vpaddlq_s32 (int32x4_t a)
        ///A32: VPADDL.S32 Qd, Qm
        ///A64: SADDLP Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vpaddlq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddlq_s32", Category)]
        public object vpaddlq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// int16x8_t vpaddlq_s8 (int8x16_t a)
        ///A32: VPADDL.S8 Qd, Qm
        ///A64: SADDLP Vd.8H, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vpaddlq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddlq_s8", Category)]
        public object vpaddlq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// uint32x4_t vpaddlq_u16 (uint16x8_t a)
        ///A32: VPADDL.U16 Qd, Qm
        ///A64: UADDLP Vd.4S, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vpaddlq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddlq_u16", Category)]
        public object vpaddlq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// uint64x2_t vpaddlq_u32 (uint32x4_t a)
        ///A32: VPADDL.U32 Qd, Qm
        ///A64: UADDLP Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vpaddlq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddlq_u32", Category)]
        public object vpaddlq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// uint16x8_t vpaddlq_u8 (uint8x16_t a)
        ///A32: VPADDL.U8 Qd, Qm
        ///A64: UADDLP Vd.8H, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vpaddlq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddlq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddlq_u8", Category)]
        public object vpaddlq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AddPairwiseWidening);
        
        /// <summary>
        /// float32x2_t vpmax_f32 (float32x2_t a, float32x2_t b)
        ///A32: VPMAX.F32 Dd, Dn, Dm
        ///A64: FMAXP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmax_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_f32", Category)]
        public object vpmax_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// int16x4_t vpmax_s16 (int16x4_t a, int16x4_t b)
        ///A32: VPMAX.S16 Dd, Dn, Dm
        ///A64: SMAXP Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vpmax_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_s16", Category)]
        public object vpmax_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// int32x2_t vpmax_s32 (int32x2_t a, int32x2_t b)
        ///A32: VPMAX.S32 Dd, Dn, Dm
        ///A64: SMAXP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmax_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_s32", Category)]
        public object vpmax_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// int8x8_t vpmax_s8 (int8x8_t a, int8x8_t b)
        ///A32: VPMAX.S8 Dd, Dn, Dm
        ///A64: SMAXP Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vpmax_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_s8", Category)]
        public object vpmax_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// uint16x4_t vpmax_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VPMAX.U16 Dd, Dn, Dm
        ///A64: UMAXP Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vpmax_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_u16", Category)]
        public object vpmax_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// uint32x2_t vpmax_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VPMAX.U32 Dd, Dn, Dm
        ///A64: UMAXP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmax_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_u32", Category)]
        public object vpmax_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// uint8x8_t vpmax_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VPMAX.U8 Dd, Dn, Dm
        ///A64: UMAXP Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vpmax_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmax_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmax_u8", Category)]
        public object vpmax_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MaxPairwise);
        
        /// <summary>
        /// float32x2_t vpmin_f32 (float32x2_t a, float32x2_t b)
        ///A32: VPMIN.F32 Dd, Dn, Dm
        ///A64: FMINP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmin_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_f32", Category)]
        public object vpmin_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// int16x4_t vpmin_s16 (int16x4_t a, int16x4_t b)
        ///A32: VPMIN.S16 Dd, Dn, Dm
        ///A64: SMINP Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vpmin_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_s16", Category)]
        public object vpmin_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// int32x2_t vpmin_s32 (int32x2_t a, int32x2_t b)
        ///A32: VPMIN.S32 Dd, Dn, Dm
        ///A64: SMINP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmin_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_s32", Category)]
        public object vpmin_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// int8x8_t vpmin_s8 (int8x8_t a, int8x8_t b)
        ///A32: VPMIN.S8 Dd, Dn, Dm
        ///A64: SMINP Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vpmin_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_s8", Category)]
        public object vpmin_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// uint16x4_t vpmin_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VPMIN.U16 Dd, Dn, Dm
        ///A64: UMINP Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vpmin_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_u16", Category)]
        public object vpmin_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// uint32x2_t vpmin_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VPMIN.U32 Dd, Dn, Dm
        ///A64: UMINP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmin_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_u32", Category)]
        public object vpmin_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// uint8x8_t vpmin_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VPMIN.U8 Dd, Dn, Dm
        ///A64: UMINP Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vpmin_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmin_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmin_u8", Category)]
        public object vpmin_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.MinPairwise);
        
        /// <summary>
        /// int16x4_t vqabs_s16 (int16x4_t a)
        ///A32: VQABS.S16 Dd, Dm
        ///A64: SQABS Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vqabs_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabs_s16", Category)]
        public object vqabs_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsSaturate);
        
        /// <summary>
        /// int32x2_t vqabs_s32 (int32x2_t a)
        ///A32: VQABS.S32 Dd, Dm
        ///A64: SQABS Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vqabs_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabs_s32", Category)]
        public object vqabs_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsSaturate);
        
        /// <summary>
        /// int8x8_t vqabs_s8 (int8x8_t a)
        ///A32: VQABS.S8 Dd, Dm
        ///A64: SQABS Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vqabs_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabs_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabs_s8", Category)]
        public object vqabs_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsSaturate);
        
        /// <summary>
        /// int16x8_t vqabsq_s16 (int16x8_t a)
        ///A32: VQABS.S16 Qd, Qm
        ///A64: SQABS Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vqabsq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsq_s16", Category)]
        public object vqabsq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsSaturate);
        
        /// <summary>
        /// int32x4_t vqabsq_s32 (int32x4_t a)
        ///A32: VQABS.S32 Qd, Qm
        ///A64: SQABS Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vqabsq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsq_s32", Category)]
        public object vqabsq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsSaturate);
        
        /// <summary>
        /// int8x16_t vqabsq_s8 (int8x16_t a)
        ///A32: VQABS.S8 Qd, Qm
        ///A64: SQABS Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vqabsq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsq_s8", Category)]
        public object vqabsq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.AbsSaturate);
        
        /// <summary>
        /// int16x4_t vqadd_s16 (int16x4_t a, int16x4_t b)
        ///A32: VQADD.S16 Dd, Dn, Dm
        ///A64: SQADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqadd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_s16", Category)]
        public object vqadd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int32x2_t vqadd_s32 (int32x2_t a, int32x2_t b)
        ///A32: VQADD.S32 Dd, Dn, Dm
        ///A64: SQADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqadd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_s32", Category)]
        public object vqadd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int64x1_t vqadd_s64 (int64x1_t a, int64x1_t b)
        ///A32: VQADD.S64 Dd, Dn, Dm
        ///A64: SQADD Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqadd_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_s64", Category)]
        public object vqadd_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturateScalar);
        
        /// <summary>
        /// int8x8_t vqadd_s8 (int8x8_t a, int8x8_t b)
        ///A32: VQADD.S8 Dd, Dn, Dm
        ///A64: SQADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqadd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_s8", Category)]
        public object vqadd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint16x4_t vqadd_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VQADD.U16 Dd, Dn, Dm
        ///A64: UQADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqadd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_u16", Category)]
        public object vqadd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint32x2_t vqadd_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VQADD.U32 Dd, Dn, Dm
        ///A64: UQADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqadd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_u32", Category)]
        public object vqadd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint64x1_t vqadd_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VQADD.U64 Dd, Dn, Dm
        ///A64: UQADD Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqadd_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_u64", Category)]
        public object vqadd_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturateScalar);
        
        /// <summary>
        /// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VQADD.U8 Dd, Dn, Dm
        ///A64: UQADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqadd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadd_u8", Category)]
        public object vqadd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int16x8_t vqaddq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VQADD.S16 Qd, Qn, Qm
        ///A64: SQADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqaddq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_s16", Category)]
        public object vqaddq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int32x4_t vqaddq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VQADD.S32 Qd, Qn, Qm
        ///A64: SQADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqaddq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_s32", Category)]
        public object vqaddq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int64x2_t vqaddq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VQADD.S64 Qd, Qn, Qm
        ///A64: SQADD Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqaddq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_s64", Category)]
        public object vqaddq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int8x16_t vqaddq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VQADD.S8 Qd, Qn, Qm
        ///A64: SQADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqaddq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_s8", Category)]
        public object vqaddq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint16x8_t vqaddq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VQADD.U16 Qd, Qn, Qm
        ///A64: UQADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqaddq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_u16", Category)]
        public object vqaddq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint32x4_t vqaddq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VQADD.U32 Qd, Qn, Qm
        ///A64: UQADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqaddq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_u32", Category)]
        public object vqaddq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint64x2_t vqaddq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VQADD.U64 Qd, Qn, Qm
        ///A64: UQADD Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqaddq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_u64", Category)]
        public object vqaddq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// uint8x16_t vqaddq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VQADD.U8 Qd, Qn, Qm
        ///A64: UQADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqaddq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddq_u8", Category)]
        public object vqaddq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddSaturate);
        
        /// <summary>
        /// int16x4_t vqneg_s16 (int16x4_t a)
        ///A32: VQNEG.S16 Dd, Dm
        ///A64: SQNEG Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vqneg_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqneg_s16", Category)]
        public object vqneg_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateSaturate);
        
        /// <summary>
        /// int32x2_t vqneg_s32 (int32x2_t a)
        ///A32: VQNEG.S32 Dd, Dm
        ///A64: SQNEG Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vqneg_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqneg_s32", Category)]
        public object vqneg_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateSaturate);
        
        /// <summary>
        /// int8x8_t vqneg_s8 (int8x8_t a)
        ///A32: VQNEG.S8 Dd, Dm
        ///A64: SQNEG Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vqneg_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqneg_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqneg_s8", Category)]
        public object vqneg_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateSaturate);
        
        /// <summary>
        /// int16x8_t vqnegq_s16 (int16x8_t a)
        ///A32: VQNEG.S16 Qd, Qm
        ///A64: SQNEG Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vqnegq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegq_s16", Category)]
        public object vqnegq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateSaturate);
        
        /// <summary>
        /// int32x4_t vqnegq_s32 (int32x4_t a)
        ///A32: VQNEG.S32 Qd, Qm
        ///A64: SQNEG Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vqnegq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegq_s32", Category)]
        public object vqnegq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateSaturate);
        
        /// <summary>
        /// int8x16_t vqnegq_s8 (int8x16_t a)
        ///A32: VQNEG.S8 Qd, Qm
        ///A64: SQNEG Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vqnegq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegq_s8", Category)]
        public object vqnegq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.NegateSaturate);
        
        /// <summary>
        /// int16x4_t vqrshl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VQRSHL.S16 Dd, Dn, Dm
        ///A64: SQRSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqrshl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_s16", Category)]
        public object vqrshl_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// int32x2_t vqrshl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VQRSHL.S32 Dd, Dn, Dm
        ///A64: SQRSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqrshl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_s32", Category)]
        public object vqrshl_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// int64x1_t vqrshl_s64 (int64x1_t a, int64x1_t b)
        ///A32: VQRSHL.S64 Dd, Dn, Dm
        ///A64: SQRSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqrshl_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_s64", Category)]
        public object vqrshl_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturateScalar);
        
        /// <summary>
        /// int8x8_t vqrshl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VQRSHL.S8 Dd, Dn, Dm
        ///A64: SQRSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqrshl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_s8", Category)]
        public object vqrshl_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b)
        ///A32: VQRSHL.U16 Dd, Dn, Dm
        ///A64: UQRSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqrshl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_u16", Category)]
        public object vqrshl_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b)
        ///A32: VQRSHL.U32 Dd, Dn, Dm
        ///A64: UQRSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqrshl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_u32", Category)]
        public object vqrshl_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b)
        ///A32: VQRSHL.U64 Dd, Dn, Dm
        ///A64: UQRSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqrshl_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_u64", Category)]
        public object vqrshl_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturateScalar);
        
        /// <summary>
        /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b)
        ///A32: VQRSHL.U8 Dd, Dn, Dm
        ///A64: UQRSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqrshl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshl_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshl_u8", Category)]
        public object vqrshl_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// int16x8_t vqrshlq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VQRSHL.S16 Qd, Qn, Qm
        ///A64: SQRSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqrshlq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_s16", Category)]
        public object vqrshlq_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// int32x4_t vqrshlq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VQRSHL.S32 Qd, Qn, Qm
        ///A64: SQRSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqrshlq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_s32", Category)]
        public object vqrshlq_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// int64x2_t vqrshlq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VQRSHL.S64 Qd, Qn, Qm
        ///A64: SQRSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqrshlq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_s64", Category)]
        public object vqrshlq_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// int8x16_t vqrshlq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VQRSHL.S8 Qd, Qn, Qm
        ///A64: SQRSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqrshlq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_s8", Category)]
        public object vqrshlq_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedSaturate);
        
        /// <summary>
        /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b)
        ///A32: VQRSHL.U16 Qd, Qn, Qm
        ///A64: UQRSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqrshlq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_u16", Category)]
        public object vqrshlq_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b)
        ///A32: VQRSHL.U32 Qd, Qn, Qm
        ///A64: UQRSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqrshlq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_u32", Category)]
        public object vqrshlq_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b)
        ///A32: VQRSHL.U64 Qd, Qn, Qm
        ///A64: UQRSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqrshlq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_u64", Category)]
        public object vqrshlq_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b)
        ///A32: VQRSHL.U8 Qd, Qn, Qm
        ///A64: UQRSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqrshlq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlq_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlq_u8", Category)]
        public object vqrshlq_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedSaturate);
        
        /// <summary>
        /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
        ///A32: VQRSHRN.S16 Dd+1, Dn, #n
        ///A64: SQRSHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_high_n_s16", Category)]
        public object vqrshrn_high_n_s16(object lower, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUpper);
        
        /// <summary>
        /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
        ///A32: VQRSHRN.S32 Dd+1, Dn, #n
        ///A64: SQRSHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_high_n_s32", Category)]
        public object vqrshrn_high_n_s32(object lower, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUpper);
        
        /// <summary>
        /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
        ///A32: VQRSHRN.S64 Dd+1, Dn, #n
        ///A64: SQRSHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_high_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_high_n_s64", Category)]
        public object vqrshrn_high_n_s64(object lower, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUpper);
        
        /// <summary>
        /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
        ///A32: VQRSHRN.U16 Dd+1, Dn, #n
        ///A64: UQRSHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_high_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_u16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_high_n_u16", Category)]
        public object vqrshrn_high_n_u16(object lower, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper);
        
        /// <summary>
        /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
        ///A32: VQRSHRN.U32 Dd+1, Dn, #n
        ///A64: UQRSHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_high_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_u32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_high_n_u32", Category)]
        public object vqrshrn_high_n_u32(object lower, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper);
        
        /// <summary>
        /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
        ///A32: VQRSHRN.U64 Dd+1, Dn, #n
        ///A64: UQRSHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_high_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_high_n_u64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_high_n_u64", Category)]
        public object vqrshrn_high_n_u64(object lower, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper);
        
        /// <summary>
        /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n)
        ///A32: VQRSHRN.S16 Dd, Qm, #n
        ///A64: SQRSHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_n_s16", Category)]
        public object vqrshrn_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateLower);
        
        /// <summary>
        /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n)
        ///A32: VQRSHRN.S32 Dd, Qm, #n
        ///A64: SQRSHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_n_s32", Category)]
        public object vqrshrn_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateLower);
        
        /// <summary>
        /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n)
        ///A32: VQRSHRN.S64 Dd, Qm, #n
        ///A64: SQRSHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_n_s64", Category)]
        public object vqrshrn_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateLower);
        
        /// <summary>
        /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n)
        ///A32: VQRSHRN.U16 Dd, Qm, #n
        ///A64: UQRSHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_n_u16", Category)]
        public object vqrshrn_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower);
        
        /// <summary>
        /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n)
        ///A32: VQRSHRN.U32 Dd, Qm, #n
        ///A64: UQRSHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_n_u32", Category)]
        public object vqrshrn_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower);
        
        /// <summary>
        /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n)
        ///A32: VQRSHRN.U64 Dd, Qm, #n
        ///A64: UQRSHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrn_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrn_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrn_n_u64", Category)]
        public object vqrshrn_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower);
        
        /// <summary>
        /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n)
        ///A32: VQRSHRUN.S16 Dd+1, Dn, #n
        ///A64: SQRSHRUN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrun_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_high_n_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrun_high_n_s16", Category)]
        public object vqrshrun_high_n_s16(object lower, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper);
        
        /// <summary>
        /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n)
        ///A32: VQRSHRUN.S32 Dd+1, Dn, #n
        ///A64: SQRSHRUN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrun_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_high_n_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrun_high_n_s32", Category)]
        public object vqrshrun_high_n_s32(object lower, object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper);
        
        /// <summary>
        /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n)
        ///A32: VQRSHRUN.S64 Dd+1, Dn, #n
        ///A64: SQRSHRUN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrun_high_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_high_n_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrun_high_n_s64", Category)]
        public object vqrshrun_high_n_s64(object lower, object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper);
        
        /// <summary>
        /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n)
        ///A32: VQRSHRUN.S16 Dd, Qm, #n
        ///A64: SQRSHRUN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrun_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrun_n_s16", Category)]
        public object vqrshrun_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower);
        
        /// <summary>
        /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n)
        ///A32: VQRSHRUN.S32 Dd, Qm, #n
        ///A64: SQRSHRUN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrun_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrun_n_s32", Category)]
        public object vqrshrun_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower);
        
        /// <summary>
        /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n)
        ///A32: VQRSHRUN.S64 Dd, Qm, #n
        ///A64: SQRSHRUN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrun_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrun_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrun_n_s64", Category)]
        public object vqrshrun_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower);
        
        /// <summary>
        /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n)
        ///A32: VQSHL.S16 Dd, Dm, #n
        ///A64: SQSHL Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_s16", Category)]
        public object vqshl_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n)
        ///A32: VQSHL.S32 Dd, Dm, #n
        ///A64: SQSHL Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_s32", Category)]
        public object vqshl_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n)
        ///A32: VQSHL.S64 Dd, Dm, #n
        ///A64: SQSHL Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_s64", Category)]
        public object vqshl_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n)
        ///A32: VQSHL.S8 Dd, Dm, #n
        ///A64: SQSHL Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_s8", Category)]
        public object vqshl_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n)
        ///A32: VQSHL.U16 Dd, Dm, #n
        ///A64: UQSHL Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_u16", Category)]
        public object vqshl_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n)
        ///A32: VQSHL.U32 Dd, Dm, #n
        ///A64: UQSHL Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_u32", Category)]
        public object vqshl_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n)
        ///A32: VQSHL.U64 Dd, Dm, #n
        ///A64: UQSHL Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_u64", Category)]
        public object vqshl_n_u64(object value, byte count) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n)
        ///A32: VQSHL.U8 Dd, Dm, #n
        ///A64: UQSHL Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vqshl_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_n_u8", Category)]
        public object vqshl_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int16x4_t vqshl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VQSHL.S16 Dd, Dn, Dm
        ///A64: SQSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqshl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_s16", Category)]
        public object vqshl_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// int32x2_t vqshl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VQSHL.S32 Dd, Dn, Dm
        ///A64: SQSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqshl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_s32", Category)]
        public object vqshl_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// int64x1_t vqshl_s64 (int64x1_t a, int64x1_t b)
        ///A32: VQSHL.S64 Dd, Dn, Dm
        ///A64: SQSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqshl_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_s64", Category)]
        public object vqshl_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturateScalar);
        
        /// <summary>
        /// int8x8_t vqshl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VQSHL.S8 Dd, Dn, Dm
        ///A64: SQSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqshl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_s8", Category)]
        public object vqshl_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b)
        ///A32: VQSHL.U16 Dd, Dn, Dm
        ///A64: UQSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqshl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_u16", Category)]
        public object vqshl_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b)
        ///A32: VQSHL.U32 Dd, Dn, Dm
        ///A64: UQSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqshl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_u32", Category)]
        public object vqshl_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b)
        ///A32: VQSHL.U64 Dd, Dn, Dm
        ///A64: UQSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqshl_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_u64", Category)]
        public object vqshl_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturateScalar);
        
        /// <summary>
        /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b)
        ///A32: VQSHL.U8 Dd, Dn, Dm
        ///A64: UQSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqshl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshl_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshl_u8", Category)]
        public object vqshl_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n)
        ///A32: VQSHL.S16 Qd, Qm, #n
        ///A64: SQSHL Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_s16", Category)]
        public object vqshlq_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n)
        ///A32: VQSHL.S32 Qd, Qm, #n
        ///A64: SQSHL Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_s32", Category)]
        public object vqshlq_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n)
        ///A32: VQSHL.S64 Qd, Qm, #n
        ///A64: SQSHL Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_s64", Category)]
        public object vqshlq_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n)
        ///A32: VQSHL.S8 Qd, Qm, #n
        ///A64: SQSHL Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_s8", Category)]
        public object vqshlq_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n)
        ///A32: VQSHL.U16 Qd, Qm, #n
        ///A64: UQSHL Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_u16", Category)]
        public object vqshlq_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n)
        ///A32: VQSHL.U32 Qd, Qm, #n
        ///A64: UQSHL Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_u32", Category)]
        public object vqshlq_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n)
        ///A32: VQSHL.U64 Qd, Qm, #n
        ///A64: UQSHL Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_u64", Category)]
        public object vqshlq_n_u64(object value, byte count) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n)
        ///A32: VQSHL.U8 Qd, Qm, #n
        ///A64: UQSHL Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vqshlq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_n_u8", Category)]
        public object vqshlq_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate);
        
        /// <summary>
        /// int16x8_t vqshlq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VQSHL.S16 Qd, Qn, Qm
        ///A64: SQSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqshlq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_s16", Category)]
        public object vqshlq_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// int32x4_t vqshlq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VQSHL.S32 Qd, Qn, Qm
        ///A64: SQSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqshlq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_s32", Category)]
        public object vqshlq_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// int64x2_t vqshlq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VQSHL.S64 Qd, Qn, Qm
        ///A64: SQSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqshlq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_s64", Category)]
        public object vqshlq_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// int8x16_t vqshlq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VQSHL.S8 Qd, Qn, Qm
        ///A64: SQSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqshlq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_s8", Category)]
        public object vqshlq_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticSaturate);
        
        /// <summary>
        /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b)
        ///A32: VQSHL.U16 Qd, Qn, Qm
        ///A64: UQSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqshlq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_u16", Category)]
        public object vqshlq_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b)
        ///A32: VQSHL.U32 Qd, Qn, Qm
        ///A64: UQSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqshlq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_u32", Category)]
        public object vqshlq_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b)
        ///A32: VQSHL.U64 Qd, Qn, Qm
        ///A64: UQSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqshlq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_u64", Category)]
        public object vqshlq_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b)
        ///A32: VQSHL.U8 Qd, Qn, Qm
        ///A64: UQSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqshlq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlq_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlq_u8", Category)]
        public object vqshlq_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalSaturate);
        
        /// <summary>
        /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n)
        ///A32: VQSHLU.S16 Dd, Dm, #n
        ///A64: SQSHLU Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vqshlu_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlu_n_s16", Category)]
        public object vqshlu_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n)
        ///A32: VQSHLU.S32 Dd, Dm, #n
        ///A64: SQSHLU Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vqshlu_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlu_n_s32", Category)]
        public object vqshlu_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n)
        ///A32: VQSHLU.S64 Dd, Dm, #n
        ///A64: SQSHLU Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlu_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlu_n_s64", Category)]
        public object vqshlu_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsignedScalar);
        
        /// <summary>
        /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n)
        ///A32: VQSHLU.S8 Dd, Dm, #n
        ///A64: SQSHLU Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vqshlu_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlu_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlu_n_s8", Category)]
        public object vqshlu_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n)
        ///A32: VQSHLU.S16 Qd, Qm, #n
        ///A64: SQSHLU Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshluq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshluq_n_s16", Category)]
        public object vqshluq_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n)
        ///A32: VQSHLU.S32 Qd, Qm, #n
        ///A64: SQSHLU Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshluq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshluq_n_s32", Category)]
        public object vqshluq_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n)
        ///A32: VQSHLU.S64 Qd, Qm, #n
        ///A64: SQSHLU Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshluq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshluq_n_s64", Category)]
        public object vqshluq_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n)
        ///A32: VQSHLU.S8 Qd, Qm, #n
        ///A64: SQSHLU Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vqshluq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluq_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshluq_n_s8", Category)]
        public object vqshluq_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned);
        
        /// <summary>
        /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
        ///A32: VQSHRN.S16 Dd+1, Qm, #n
        ///A64: SQSHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_high_n_s16", Category)]
        public object vqshrn_high_n_s16(object lower, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUpper);
        
        /// <summary>
        /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
        ///A32: VQSHRN.S32 Dd+1, Qm, #n
        ///A64: SQSHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_high_n_s32", Category)]
        public object vqshrn_high_n_s32(object lower, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUpper);
        
        /// <summary>
        /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
        ///A32: VQSHRN.S64 Dd+1, Qm, #n
        ///A64: SQSHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_high_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_high_n_s64", Category)]
        public object vqshrn_high_n_s64(object lower, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUpper);
        
        /// <summary>
        /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
        ///A32: VQSHRN.U16 Dd+1, Qm, #n
        ///A64: UQSHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_high_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_u16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_high_n_u16", Category)]
        public object vqshrn_high_n_u16(object lower, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper);
        
        /// <summary>
        /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
        ///A32: VQSHRN.U32 Dd+1, Qm, #n
        ///A64: UQSHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_high_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_u32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_high_n_u32", Category)]
        public object vqshrn_high_n_u32(object lower, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper);
        
        /// <summary>
        /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
        ///A32: VQSHRN.U64 Dd+1, Qm, #n
        ///A64: UQSHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_high_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_high_n_u64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_high_n_u64", Category)]
        public object vqshrn_high_n_u64(object lower, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper);
        
        /// <summary>
        /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n)
        ///A32: VQSHRN.S16 Dd, Qm, #n
        ///A64: SQSHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_n_s16", Category)]
        public object vqshrn_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateLower);
        
        /// <summary>
        /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n)
        ///A32: VQSHRN.S32 Dd, Qm, #n
        ///A64: SQSHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_n_s32", Category)]
        public object vqshrn_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateLower);
        
        /// <summary>
        /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n)
        ///A32: VQSHRN.S64 Dd, Qm, #n
        ///A64: SQSHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_n_s64", Category)]
        public object vqshrn_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateLower);
        
        /// <summary>
        /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n)
        ///A32: VQSHRN.U16 Dd, Qm, #n
        ///A64: UQSHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_n_u16", Category)]
        public object vqshrn_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower);
        
        /// <summary>
        /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n)
        ///A32: VQSHRN.U32 Dd, Qm, #n
        ///A64: UQSHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_n_u32", Category)]
        public object vqshrn_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower);
        
        /// <summary>
        /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n)
        ///A32: VQSHRN.U64 Dd, Qm, #n
        ///A64: UQSHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshrn_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrn_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrn_n_u64", Category)]
        public object vqshrn_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower);
        
        /// <summary>
        /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n)
        ///A32: VQSHRUN.S16 Dd+1, Dn, #n
        ///A64: SQSHRUN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshrun_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_high_n_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrun_high_n_s16", Category)]
        public object vqshrun_high_n_s16(object lower, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedUpper);
        
        /// <summary>
        /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n)
        ///A32: VQSHRUN.S32 Dd+1, Dn, #n
        ///A64: SQSHRUN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshrun_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_high_n_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrun_high_n_s32", Category)]
        public object vqshrun_high_n_s32(object lower, object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedUpper);
        
        /// <summary>
        /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n)
        ///A32: VQSHRUN.S64 Dd+1, Dn, #n
        ///A64: SQSHRUN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshrun_high_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_high_n_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrun_high_n_s64", Category)]
        public object vqshrun_high_n_s64(object lower, object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedUpper);
        
        /// <summary>
        /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n)
        ///A32: VQSHRUN.S16 Dd, Qm, #n
        ///A64: SQSHRUN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vqshrun_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrun_n_s16", Category)]
        public object vqshrun_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedLower);
        
        /// <summary>
        /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n)
        ///A32: VQSHRUN.S32 Dd, Qm, #n
        ///A64: SQSHRUN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vqshrun_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrun_n_s32", Category)]
        public object vqshrun_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedLower);
        
        /// <summary>
        /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n)
        ///A32: VQSHRUN.S64 Dd, Qm, #n
        ///A64: SQSHRUN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vqshrun_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrun_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrun_n_s64", Category)]
        public object vqshrun_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedLower);
        
        /// <summary>
        /// int16x4_t vqsub_s16 (int16x4_t a, int16x4_t b)
        ///A32: VQSUB.S16 Dd, Dn, Dm
        ///A64: SQSUB Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqsub_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_s16", Category)]
        public object vqsub_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int32x2_t vqsub_s32 (int32x2_t a, int32x2_t b)
        ///A32: VQSUB.S32 Dd, Dn, Dm
        ///A64: SQSUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqsub_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_s32", Category)]
        public object vqsub_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int64x1_t vqsub_s64 (int64x1_t a, int64x1_t b)
        ///A32: VQSUB.S64 Dd, Dn, Dm
        ///A64: SQSUB Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqsub_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_s64", Category)]
        public object vqsub_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturateScalar);
        
        /// <summary>
        /// int8x8_t vqsub_s8 (int8x8_t a, int8x8_t b)
        ///A32: VQSUB.S8 Dd, Dn, Dm
        ///A64: SQSUB Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqsub_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_s8", Category)]
        public object vqsub_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint16x4_t vqsub_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VQSUB.U16 Dd, Dn, Dm
        ///A64: UQSUB Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vqsub_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_u16", Category)]
        public object vqsub_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint32x2_t vqsub_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VQSUB.U32 Dd, Dn, Dm
        ///A64: UQSUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vqsub_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_u32", Category)]
        public object vqsub_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint64x1_t vqsub_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VQSUB.U64 Dd, Dn, Dm
        ///A64: UQSUB Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vqsub_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_u64", Category)]
        public object vqsub_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturateScalar);
        
        /// <summary>
        /// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VQSUB.U8 Dd, Dn, Dm
        ///A64: UQSUB Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqsub_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsub_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsub_u8", Category)]
        public object vqsub_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int16x8_t vqsubq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VQSUB.S16 Qd, Qn, Qm
        ///A64: SQSUB Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqsubq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_s16", Category)]
        public object vqsubq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int32x4_t vqsubq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VQSUB.S32 Qd, Qn, Qm
        ///A64: SQSUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqsubq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_s32", Category)]
        public object vqsubq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int64x2_t vqsubq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VQSUB.S64 Qd, Qn, Qm
        ///A64: SQSUB Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqsubq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_s64", Category)]
        public object vqsubq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int8x16_t vqsubq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VQSUB.S8 Qd, Qn, Qm
        ///A64: SQSUB Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqsubq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_s8", Category)]
        public object vqsubq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint16x8_t vqsubq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VQSUB.U16 Qd, Qn, Qm
        ///A64: UQSUB Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vqsubq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_u16", Category)]
        public object vqsubq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint32x4_t vqsubq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VQSUB.U32 Qd, Qn, Qm
        ///A64: UQSUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vqsubq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_u32", Category)]
        public object vqsubq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint64x2_t vqsubq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VQSUB.U64 Qd, Qn, Qm
        ///A64: UQSUB Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vqsubq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_u64", Category)]
        public object vqsubq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// uint8x16_t vqsubq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VQSUB.U8 Qd, Qn, Qm
        ///A64: UQSUB Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqsubq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubq_u8", Category)]
        public object vqsubq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractSaturate);
        
        /// <summary>
        /// int8x8_t vqvtbl1_s8(int8x16_t t, uint8x8_t idx)
        ///A32: VTBL Dd, {Dn, Dn+1}, Dm
        ///A64: TBL Vd.8B, {Vn.16B}, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqvtbl1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbl1_s8)
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbl1_s8", Category)]
        public object vqvtbl1_s8(object table, object byteIndexes) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.VectorTableLookup);
        
        /// <summary>
        /// uint8x8_t vqvtbl1_u8(uint8x16_t t, uint8x8_t idx)
        ///A32: VTBL Dd, {Dn, Dn+1}, Dm
        ///A64: TBL Vd.8B, {Vn.16B}, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqvtbl1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbl1_u8)
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbl1_u8", Category)]
        public object vqvtbl1_u8(object table, object byteIndexes) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.VectorTableLookup);
        
        /// <summary>
        /// int8x8_t vqvtbx1_s8(int8x8_t r, int8x16_t t, uint8x8_t idx)
        ///A32: VTBX Dd, {Dn, Dn+1}, Dm
        ///A64: TBX Vd.8B, {Vn.16B}, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqvtbx1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbx1_s8)
        /// <param name="defaultValues"></param>
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbx1_s8", Category)]
        public object vqvtbx1_s8(object defaultValues, object table, object byteIndexes) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(defaultValues, table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.VectorTableLookupExtension);
        
        /// <summary>
        /// uint8x8_t vqvtbx1_u8(uint8x8_t r, uint8x16_t t, uint8x8_t idx)
        ///A32: VTBX Dd, {Dn, Dn+1}, Dm
        ///A64: TBX Vd.8B, {Vn.16B}, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vqvtbx1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbx1_u8)
        /// <param name="defaultValues"></param>
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbx1_u8", Category)]
        public object vqvtbx1_u8(object defaultValues, object table, object byteIndexes) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(defaultValues, table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.VectorTableLookupExtension);
        
        /// <summary>
        /// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
        ///A32: VRADDHN.I16 Dd+1, Qn, Qm
        ///A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vraddhn_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_high_s16", Category)]
        public object vraddhn_high_s16(object lower, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
        ///A32: VRADDHN.I32 Dd+1, Qn, Qm
        ///A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vraddhn_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_high_s32", Category)]
        public object vraddhn_high_s32(object lower, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
        ///A32: VRADDHN.I64 Dd+1, Qn, Qm
        ///A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vraddhn_high_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_s64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_high_s64", Category)]
        public object vraddhn_high_s64(object lower, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
        ///A32: VRADDHN.I16 Dd+1, Qn, Qm
        ///A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vraddhn_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_u16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_high_u16", Category)]
        public object vraddhn_high_u16(object lower, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
        ///A32: VRADDHN.I32 Dd+1, Qn, Qm
        ///A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vraddhn_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_u32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_high_u32", Category)]
        public object vraddhn_high_u32(object lower, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
        ///A32: VRADDHN.I64 Dd+1, Qn, Qm
        ///A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vraddhn_high_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_high_u64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_high_u64", Category)]
        public object vraddhn_high_u64(object lower, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b)
        ///A32: VRADDHN.I16 Dd, Qn, Qm
        ///A64: RADDHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vraddhn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_s16", Category)]
        public object vraddhn_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingLower);
        
        /// <summary>
        /// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b)
        ///A32: VRADDHN.I32 Dd, Qn, Qm
        ///A64: RADDHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vraddhn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_s32", Category)]
        public object vraddhn_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingLower);
        
        /// <summary>
        /// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b)
        ///A32: VRADDHN.I64 Dd, Qn, Qm
        ///A64: RADDHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vraddhn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_s64", Category)]
        public object vraddhn_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VRADDHN.I16 Dd, Qn, Qm
        ///A64: RADDHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vraddhn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_u16", Category)]
        public object vraddhn_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VRADDHN.I32 Dd, Qn, Qm
        ///A64: RADDHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vraddhn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_u32", Category)]
        public object vraddhn_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VRADDHN.I64 Dd, Qn, Qm
        ///A64: RADDHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vraddhn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vraddhn_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vraddhn_u64", Category)]
        public object vraddhn_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.AddRoundedHighNarrowingLower);
        
        /// <summary>
        /// float32x2_t vrecpe_f32 (float32x2_t a)
        ///A32: VRECPE.F32 Dd, Dm
        ///A64: FRECPE Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrecpe_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpe_f32", Category)]
        public object vrecpe_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalEstimate);
        
        /// <summary>
        /// uint32x2_t vrecpe_u32 (uint32x2_t a)
        ///A32: VRECPE.U32 Dd, Dm
        ///A64: URECPE Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrecpe_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpe_u32", Category)]
        public object vrecpe_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalEstimate);
        
        /// <summary>
        /// float32x4_t vrecpeq_f32 (float32x4_t a)
        ///A32: VRECPE.F32 Qd, Qm
        ///A64: FRECPE Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrecpeq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpeq_f32", Category)]
        public object vrecpeq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalEstimate);
        
        /// <summary>
        /// uint32x4_t vrecpeq_u32 (uint32x4_t a)
        ///A32: VRECPE.U32 Qd, Qm
        ///A64: URECPE Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrecpeq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpeq_u32", Category)]
        public object vrecpeq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalEstimate);
        
        /// <summary>
        /// float32x2_t vrecps_f32 (float32x2_t a, float32x2_t b)
        ///A32: VRECPS.F32 Dd, Dn, Dm
        ///A64: FRECPS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vrecps_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecps_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrecps_f32", Category)]
        public object vrecps_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalStep);
        
        /// <summary>
        /// float32x4_t vrecpsq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VRECPS.F32 Qd, Qn, Qm
        ///A64: FRECPS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrecpsq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrecpsq_f32", Category)]
        public object vrecpsq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalStep);
        
        /// <summary>
        /// int16x4_t vrhadd_s16 (int16x4_t a, int16x4_t b)
        ///A32: VRHADD.S16 Dd, Dn, Dm
        ///A64: SRHADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vrhadd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhadd_s16", Category)]
        public object vrhadd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// int32x2_t vrhadd_s32 (int32x2_t a, int32x2_t b)
        ///A32: VRHADD.S32 Dd, Dn, Dm
        ///A64: SRHADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vrhadd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhadd_s32", Category)]
        public object vrhadd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// int8x8_t vrhadd_s8 (int8x8_t a, int8x8_t b)
        ///A32: VRHADD.S8 Dd, Dn, Dm
        ///A64: SRHADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vrhadd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhadd_s8", Category)]
        public object vrhadd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// uint16x4_t vrhadd_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VRHADD.U16 Dd, Dn, Dm
        ///A64: URHADD Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vrhadd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhadd_u16", Category)]
        public object vrhadd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// uint32x2_t vrhadd_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VRHADD.U32 Dd, Dn, Dm
        ///A64: URHADD Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vrhadd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhadd_u32", Category)]
        public object vrhadd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// uint8x8_t vrhadd_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VRHADD.U8 Dd, Dn, Dm
        ///A64: URHADD Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vrhadd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhadd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhadd_u8", Category)]
        public object vrhadd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// int16x8_t vrhaddq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VRHADD.S16 Qd, Qn, Qm
        ///A64: SRHADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrhaddq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhaddq_s16", Category)]
        public object vrhaddq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// int32x4_t vrhaddq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VRHADD.S32 Qd, Qn, Qm
        ///A64: SRHADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrhaddq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhaddq_s32", Category)]
        public object vrhaddq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// int8x16_t vrhaddq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VRHADD.S8 Qd, Qn, Qm
        ///A64: SRHADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vrhaddq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhaddq_s8", Category)]
        public object vrhaddq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// uint16x8_t vrhaddq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VRHADD.U16 Qd, Qn, Qm
        ///A64: URHADD Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrhaddq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhaddq_u16", Category)]
        public object vrhaddq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// uint32x4_t vrhaddq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VRHADD.U32 Qd, Qn, Qm
        ///A64: URHADD Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrhaddq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhaddq_u32", Category)]
        public object vrhaddq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// uint8x16_t vrhaddq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VRHADD.U8 Qd, Qn, Qm
        ///A64: URHADD Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vrhaddq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrhaddq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrhaddq_u8", Category)]
        public object vrhaddq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.FusedAddRoundedHalving);
        
        /// <summary>
        /// float32x2_t vrnd_f32 (float32x2_t a)
        ///A32: VRINTZ.F32 Dd, Dm
        ///A64: FRINTZ Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrnd_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrnd_f32", Category)]
        public object vrnd_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToZero);
        
        /// <summary>
        /// float64x1_t vrnd_f64 (float64x1_t a)
        ///A32: VRINTZ.F64 Dd, Dm
        ///A64: FRINTZ Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrnd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrnd_f64", Category)]
        public object vrnd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToZeroScalar);
        
        /// <summary>
        /// float32x2_t vrnda_f32 (float32x2_t a)
        ///A32: VRINTA.F32 Dd, Dm
        ///A64: FRINTA Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrnda_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnda_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrnda_f32", Category)]
        public object vrnda_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundAwayFromZero);
        
        /// <summary>
        /// float64x1_t vrnda_f64 (float64x1_t a)
        ///A32: VRINTA.F64 Dd, Dm
        ///A64: FRINTA Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrnda_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnda_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrnda_f64", Category)]
        public object vrnda_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundAwayFromZeroScalar);
        
        /// <summary>
        /// float32x4_t vrndaq_f32 (float32x4_t a)
        ///A32: VRINTA.F32 Qd, Qm
        ///A64: FRINTA Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrndaq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndaq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndaq_f32", Category)]
        public object vrndaq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundAwayFromZero);
        
        /// <summary>
        /// float32_t vrndas_f32 (float32_t a)
        ///A32: VRINTA.F32 Sd, Sm
        ///A64: FRINTA Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vrndas_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndas_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndas_f32", Category)]
        public object vrndas_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundAwayFromZeroScalar);
        
        /// <summary>
        /// float32x2_t vrndm_f32 (float32x2_t a)
        ///A32: VRINTM.F32 Dd, Dm
        ///A64: FRINTM Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrndm_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndm_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndm_f32", Category)]
        public object vrndm_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNegativeInfinity);
        
        /// <summary>
        /// float64x1_t vrndm_f64 (float64x1_t a)
        ///A32: VRINTM.F64 Dd, Dm
        ///A64: FRINTM Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrndm_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndm_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndm_f64", Category)]
        public object vrndm_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.FloorScalar);
        
        /// <summary>
        /// float32x4_t vrndmq_f32 (float32x4_t a)
        ///A32: VRINTM.F32 Qd, Qm
        ///A64: FRINTM Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrndmq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndmq_f32", Category)]
        public object vrndmq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNegativeInfinity);
        
        /// <summary>
        /// float32_t vrndms_f32 (float32_t a)
        ///A32: VRINTM.F32 Sd, Sm
        ///A64: FRINTM Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vrndms_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndms_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndms_f32", Category)]
        public object vrndms_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// float32x2_t vrndn_f32 (float32x2_t a)
        ///A32: VRINTN.F32 Dd, Dm
        ///A64: FRINTN Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrndn_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndn_f32", Category)]
        public object vrndn_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNearest);
        
        /// <summary>
        /// float64x1_t vrndn_f64 (float64x1_t a)
        ///A32: VRINTN.F64 Dd, Dm
        ///A64: FRINTN Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrndn_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndn_f64", Category)]
        public object vrndn_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNearestScalar);
        
        /// <summary>
        /// float32x4_t vrndnq_f32 (float32x4_t a)
        ///A32: VRINTN.F32 Qd, Qm
        ///A64: FRINTN Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrndnq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndnq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndnq_f32", Category)]
        public object vrndnq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNearest);
        
        /// <summary>
        /// float32_t vrndns_f32 (float32_t a)
        ///A32: VRINTN.F32 Sd, Sm
        ///A64: FRINTN Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vrndns_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndns_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndns_f32", Category)]
        public object vrndns_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToNearestScalar);
        
        /// <summary>
        /// float32x2_t vrndp_f32 (float32x2_t a)
        ///A32: VRINTP.F32 Dd, Dm
        ///A64: FRINTP Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrndp_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndp_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndp_f32", Category)]
        public object vrndp_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToPositiveInfinity);
        
        /// <summary>
        /// float64x1_t vrndp_f64 (float64x1_t a)
        ///A32: VRINTP.F64 Dd, Dm
        ///A64: FRINTP Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrndp_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndp_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndp_f64", Category)]
        public object vrndp_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.CeilingScalar);
        
        /// <summary>
        /// float32x4_t vrndpq_f32 (float32x4_t a)
        ///A32: VRINTP.F32 Qd, Qm
        ///A64: FRINTP Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrndpq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndpq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndpq_f32", Category)]
        public object vrndpq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToPositiveInfinity);
        
        /// <summary>
        /// float32_t vrndps_f32 (float32_t a)
        ///A32: VRINTP.F32 Sd, Sm
        ///A64: FRINTP Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vrndps_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndps_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndps_f32", Category)]
        public object vrndps_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// float32x4_t vrndq_f32 (float32x4_t a)
        ///A32: VRINTZ.F32 Qd, Qm
        ///A64: FRINTZ Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrndq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndq_f32", Category)]
        public object vrndq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToZero);
        
        /// <summary>
        /// float32_t vrnds_f32 (float32_t a)
        ///A32: VRINTZ.F32 Sd, Sm
        ///A64: FRINTZ Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vrnds_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrnds_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrnds_f32", Category)]
        public object vrnds_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.RoundToZeroScalar);
        
        /// <summary>
        /// int16x4_t vrshl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VRSHL.S16 Dd, Dn, Dm
        ///A64: SRSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vrshl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_s16", Category)]
        public object vrshl_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// int32x2_t vrshl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VRSHL.S32 Dd, Dn, Dm
        ///A64: SRSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vrshl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_s32", Category)]
        public object vrshl_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// int64x1_t vrshl_s64 (int64x1_t a, int64x1_t b)
        ///A32: VRSHL.S64 Dd, Dn, Dm
        ///A64: SRSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vrshl_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_s64", Category)]
        public object vrshl_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRoundedScalar);
        
        /// <summary>
        /// int8x8_t vrshl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VRSHL.S8 Dd, Dn, Dm
        ///A64: SRSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vrshl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_s8", Category)]
        public object vrshl_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b)
        ///A32: VRSHL.U16 Dd, Dn, Dm
        ///A64: URSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vrshl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_u16", Category)]
        public object vrshl_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b)
        ///A32: VRSHL.U32 Dd, Dn, Dm
        ///A64: URSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vrshl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_u32", Category)]
        public object vrshl_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b)
        ///A32: VRSHL.U64 Dd, Dn, Dm
        ///A64: URSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vrshl_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_u64", Category)]
        public object vrshl_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRoundedScalar);
        
        /// <summary>
        /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b)
        ///A32: VRSHL.U8 Dd, Dn, Dm
        ///A64: URSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vrshl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshl_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshl_u8", Category)]
        public object vrshl_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// int16x8_t vrshlq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VRSHL.S16 Qd, Qn, Qm
        ///A64: SRSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrshlq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_s16", Category)]
        public object vrshlq_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// int32x4_t vrshlq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VRSHL.S32 Qd, Qn, Qm
        ///A64: SRSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrshlq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_s32", Category)]
        public object vrshlq_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// int64x2_t vrshlq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VRSHL.S64 Qd, Qn, Qm
        ///A64: SRSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrshlq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_s64", Category)]
        public object vrshlq_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// int8x16_t vrshlq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VRSHL.S8 Qd, Qn, Qm
        ///A64: SRSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vrshlq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_s8", Category)]
        public object vrshlq_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticRounded);
        
        /// <summary>
        /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b)
        ///A32: VRSHL.U16 Qd, Qn, Qm
        ///A64: URSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrshlq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_u16", Category)]
        public object vrshlq_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b)
        ///A32: VRSHL.U32 Qd, Qn, Qm
        ///A64: URSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrshlq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_u32", Category)]
        public object vrshlq_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b)
        ///A32: VRSHL.U64 Qd, Qn, Qm
        ///A64: URSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrshlq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_u64", Category)]
        public object vrshlq_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b)
        ///A32: VRSHL.U8 Qd, Qn, Qm
        ///A64: URSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vrshlq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshlq_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshlq_u8", Category)]
        public object vrshlq_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalRounded);
        
        /// <summary>
        /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n)
        ///A32: VRSHR.S16 Dd, Dm, #n
        ///A64: SRSHR Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_s16", Category)]
        public object vrshr_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n)
        ///A32: VRSHR.S32 Dd, Dm, #n
        ///A64: SRSHR Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_s32", Category)]
        public object vrshr_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n)
        ///A32: VRSHR.S64 Dd, Dm, #n
        ///A64: SRSHR Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_s64", Category)]
        public object vrshr_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedScalar);
        
        /// <summary>
        /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n)
        ///A32: VRSHR.S8 Dd, Dm, #n
        ///A64: SRSHR Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_s8", Category)]
        public object vrshr_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n)
        ///A32: VRSHR.U16 Dd, Dm, #n
        ///A64: URSHR Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_u16", Category)]
        public object vrshr_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n)
        ///A32: VRSHR.U32 Dd, Dm, #n
        ///A64: URSHR Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_u32", Category)]
        public object vrshr_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n)
        ///A32: VRSHR.U64 Dd, Dm, #n
        ///A64: URSHR Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_u64", Category)]
        public object vrshr_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedScalar);
        
        /// <summary>
        /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n)
        ///A32: VRSHR.U8 Dd, Dm, #n
        ///A64: URSHR Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vrshr_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshr_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshr_n_u8", Category)]
        public object vrshr_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
        ///A32: VRSHRN.I16 Dd+1, Qm, #n
        ///A64: RSHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_high_n_s16", Category)]
        public object vrshrn_high_n_s16(object lower, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
        ///A32: VRSHRN.I32 Dd+1, Qm, #n
        ///A64: RSHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_high_n_s32", Category)]
        public object vrshrn_high_n_s32(object lower, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
        ///A32: VRSHRN.I64 Dd+1, Qm, #n
        ///A64: RSHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_high_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_high_n_s64", Category)]
        public object vrshrn_high_n_s64(object lower, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
        ///A32: VRSHRN.I16 Dd+1, Qm, #n
        ///A64: RSHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_high_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_u16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_high_n_u16", Category)]
        public object vrshrn_high_n_u16(object lower, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
        ///A32: VRSHRN.I32 Dd+1, Qm, #n
        ///A64: RSHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_high_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_u32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_high_n_u32", Category)]
        public object vrshrn_high_n_u32(object lower, object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
        ///A32: VRSHRN.I64 Dd+1, Qm, #n
        ///A64: RSHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_high_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_high_n_u64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_high_n_u64", Category)]
        public object vrshrn_high_n_u64(object lower, object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n)
        ///A32: VRSHRN.I16 Dd, Qm, #n
        ///A64: RSHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_n_s16", Category)]
        public object vrshrn_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower);
        
        /// <summary>
        /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n)
        ///A32: VRSHRN.I32 Dd, Qm, #n
        ///A64: RSHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_n_s32", Category)]
        public object vrshrn_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower);
        
        /// <summary>
        /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n)
        ///A32: VRSHRN.I64 Dd, Qm, #n
        ///A64: RSHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_n_s64", Category)]
        public object vrshrn_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n)
        ///A32: VRSHRN.I16 Dd, Qm, #n
        ///A64: RSHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_n_u16", Category)]
        public object vrshrn_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n)
        ///A32: VRSHRN.I32 Dd, Qm, #n
        ///A64: RSHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_n_u32", Category)]
        public object vrshrn_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n)
        ///A32: VRSHRN.I64 Dd, Qm, #n
        ///A64: RSHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrshrn_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrn_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrn_n_u64", Category)]
        public object vrshrn_n_u64(object value, byte count) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower);
        
        /// <summary>
        /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n)
        ///A32: VRSHR.S16 Qd, Qm, #n
        ///A64: SRSHR Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_s16", Category)]
        public object vrshrq_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n)
        ///A32: VRSHR.S32 Qd, Qm, #n
        ///A64: SRSHR Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_s32", Category)]
        public object vrshrq_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n)
        ///A32: VRSHR.S64 Qd, Qm, #n
        ///A64: SRSHR Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_s64", Category)]
        public object vrshrq_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n)
        ///A32: VRSHR.S8 Qd, Qm, #n
        ///A64: SRSHR Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_s8", Category)]
        public object vrshrq_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded);
        
        /// <summary>
        /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n)
        ///A32: VRSHR.U16 Qd, Qm, #n
        ///A64: URSHR Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_u16", Category)]
        public object vrshrq_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
        ///A32: VRSHR.U32 Qd, Qm, #n
        ///A64: URSHR Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_u32", Category)]
        public object vrshrq_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n)
        ///A32: VRSHR.U64 Qd, Qm, #n
        ///A64: URSHR Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_u64", Category)]
        public object vrshrq_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n)
        ///A32: VRSHR.U8 Qd, Qm, #n
        ///A64: URSHR Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vrshrq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshrq_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrshrq_n_u8", Category)]
        public object vrshrq_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded);
        
        /// <summary>
        /// float32x2_t vrsqrte_f32 (float32x2_t a)
        ///A32: VRSQRTE.F32 Dd, Dm
        ///A64: FRSQRTE Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrsqrte_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrte_f32", Category)]
        public object vrsqrte_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalSquareRootEstimate);
        
        /// <summary>
        /// uint32x2_t vrsqrte_u32 (uint32x2_t a)
        ///A32: VRSQRTE.U32 Dd, Dm
        ///A64: URSQRTE Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vrsqrte_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrte_u32", Category)]
        public object vrsqrte_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalSquareRootEstimate);
        
        /// <summary>
        /// float32x4_t vrsqrteq_f32 (float32x4_t a)
        ///A32: VRSQRTE.F32 Qd, Qm
        ///A64: FRSQRTE Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrsqrteq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrteq_f32", Category)]
        public object vrsqrteq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalSquareRootEstimate);
        
        /// <summary>
        /// uint32x4_t vrsqrteq_u32 (uint32x4_t a)
        ///A32: VRSQRTE.U32 Qd, Qm
        ///A64: URSQRTE Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vrsqrteq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrteq_u32", Category)]
        public object vrsqrteq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalSquareRootEstimate);
        
        /// <summary>
        /// float32x2_t vrsqrts_f32 (float32x2_t a, float32x2_t b)
        ///A32: VRSQRTS.F32 Dd, Dn, Dm
        ///A64: FRSQRTS Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vrsqrts_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrts_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsqrts_f32", Category)]
        public object vrsqrts_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalSquareRootStep);
        
        /// <summary>
        /// float32x4_t vrsqrtsq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VRSQRTS.F32 Qd, Qn, Qm
        ///A64: FRSQRTS Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrsqrtsq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsqrtsq_f32", Category)]
        public object vrsqrtsq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.ReciprocalSquareRootStep);
        
        /// <summary>
        /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n)
        ///A32: VRSRA.S16 Dd, Dm, #n
        ///A64: SRSRA Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_s16", Category)]
        public object vrsra_n_s16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n)
        ///A32: VRSRA.S32 Dd, Dm, #n
        ///A64: SRSRA Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_s32", Category)]
        public object vrsra_n_s32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n)
        ///A32: VRSRA.S64 Dd, Dm, #n
        ///A64: SRSRA Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_s64", Category)]
        public object vrsra_n_s64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAddScalar);
        
        /// <summary>
        /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n)
        ///A32: VRSRA.S8 Dd, Dm, #n
        ///A64: SRSRA Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_s8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_s8", Category)]
        public object vrsra_n_s8(object addend, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
        ///A32: VRSRA.U16 Dd, Dm, #n
        ///A64: URSRA Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_u16", Category)]
        public object vrsra_n_u16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
        ///A32: VRSRA.U32 Dd, Dm, #n
        ///A64: URSRA Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_u32", Category)]
        public object vrsra_n_u32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
        ///A32: VRSRA.U64 Dd, Dm, #n
        ///A64: URSRA Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_u64", Category)]
        public object vrsra_n_u64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAddScalar);
        
        /// <summary>
        /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
        ///A32: VRSRA.U8 Dd, Dm, #n
        ///A64: URSRA Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vrsra_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsra_n_u8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsra_n_u8", Category)]
        public object vrsra_n_u8(object addend, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n)
        ///A32: VRSRA.S16 Qd, Qm, #n
        ///A64: SRSRA Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_s16", Category)]
        public object vrsraq_n_s16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
        ///A32: VRSRA.S32 Qd, Qm, #n
        ///A64: SRSRA Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_s32", Category)]
        public object vrsraq_n_s32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n)
        ///A32: VRSRA.S64 Qd, Qm, #n
        ///A64: SRSRA Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_s64", Category)]
        public object vrsraq_n_s64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n)
        ///A32: VRSRA.S8 Qd, Qm, #n
        ///A64: SRSRA Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_s8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_s8", Category)]
        public object vrsraq_n_s8(object addend, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd);
        
        /// <summary>
        /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
        ///A32: VRSRA.U16 Qd, Qm, #n
        ///A64: URSRA Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_u16", Category)]
        public object vrsraq_n_u16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
        ///A32: VRSRA.U32 Qd, Qm, #n
        ///A64: URSRA Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_u32", Category)]
        public object vrsraq_n_u32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
        ///A32: VRSRA.U64 Qd, Qm, #n
        ///A64: URSRA Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_u64", Category)]
        public object vrsraq_n_u64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
        ///A32: VRSRA.U8 Qd, Qm, #n
        ///A64: URSRA Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vrsraq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsraq_n_u8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vrsraq_n_u8", Category)]
        public object vrsraq_n_u8(object addend, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd);
        
        /// <summary>
        /// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
        ///A32: VRSUBHN.I16 Dd+1, Qn, Qm
        ///A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrsubhn_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_s16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_high_s16", Category)]
        public object vrsubhn_high_s16(object lower, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
        ///A32: VRSUBHN.I32 Dd+1, Qn, Qm
        ///A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrsubhn_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_s32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_high_s32", Category)]
        public object vrsubhn_high_s32(object lower, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
        ///A32: VRSUBHN.I64 Dd+1, Qn, Qm
        ///A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrsubhn_high_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_s64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_high_s64", Category)]
        public object vrsubhn_high_s64(object lower, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
        ///A32: VRSUBHN.I16 Dd+1, Qn, Qm
        ///A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrsubhn_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_u16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_high_u16", Category)]
        public object vrsubhn_high_u16(object lower, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
        ///A32: VRSUBHN.I32 Dd+1, Qn, Qm
        ///A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrsubhn_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_u32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_high_u32", Category)]
        public object vrsubhn_high_u32(object lower, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
        ///A32: VRSUBHN.I64 Dd+1, Qn, Qm
        ///A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrsubhn_high_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_high_u64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_high_u64", Category)]
        public object vrsubhn_high_u64(object lower, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b)
        ///A32: VRSUBHN.I16 Dd, Qn, Qm
        ///A64: RSUBHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrsubhn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_s16", Category)]
        public object vrsubhn_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingLower);
        
        /// <summary>
        /// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b)
        ///A32: VRSUBHN.I32 Dd, Qn, Qm
        ///A64: RSUBHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrsubhn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_s32", Category)]
        public object vrsubhn_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingLower);
        
        /// <summary>
        /// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b)
        ///A32: VRSUBHN.I64 Dd, Qn, Qm
        ///A64: RSUBHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrsubhn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_s64", Category)]
        public object vrsubhn_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VRSUBHN.I16 Dd, Qn, Qm
        ///A64: RSUBHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vrsubhn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_u16", Category)]
        public object vrsubhn_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VRSUBHN.I32 Dd, Qn, Qm
        ///A64: RSUBHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vrsubhn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_u32", Category)]
        public object vrsubhn_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VRSUBHN.I64 Dd, Qn, Qm
        ///A64: RSUBHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrsubhn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsubhn_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsubhn_u64", Category)]
        public object vrsubhn_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractRoundedHighNarrowingLower);
        
        /// <summary>
        /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane)
        ///A32: VMOV.F32 Sd, Sm
        ///A64: INS Vd.S[lane], Vn.S[0]
        ///
        ///
        ///Instruction Documentation: [vset_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_f32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_f32", Category)]
        public object vset_lane_f32(object vector, byte index, float data) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, float, float, System.Runtime.Intrinsics.Vector64<float>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane)
        ///A32: VMOV.16 Dd[lane], Rt
        ///A64: INS Vd.H[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vset_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_s16", Category)]
        public object vset_lane_s16(object vector, byte index, short data) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, short, short, System.Runtime.Intrinsics.Vector64<short>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane)
        ///A32: VMOV.32 Dd[lane], Rt
        ///A64: INS Vd.S[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vset_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_s32", Category)]
        public object vset_lane_s32(object vector, byte index, int data) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, int, int, System.Runtime.Intrinsics.Vector64<int>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane)
        ///A32: VMOV.8 Dd[lane], Rt
        ///A64: INS Vd.B[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vset_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_s8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_s8", Category)]
        public object vset_lane_s8(object vector, byte index, sbyte data) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, sbyte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane)
        ///A32: VMOV.16 Dd[lane], Rt
        ///A64: INS Vd.H[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vset_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_u16", Category)]
        public object vset_lane_u16(object vector, byte index, ushort data) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, ushort, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane)
        ///A32: VMOV.32 Dd[lane], Rt
        ///A64: INS Vd.S[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vset_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_u32", Category)]
        public object vset_lane_u32(object vector, byte index, uint data) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, uint, uint, System.Runtime.Intrinsics.Vector64<uint>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint8x8_t vset_lane_u8 (uint8_t a, uint8x8_t v, const int lane)
        ///A32: VMOV.8 Dd[lane], Rt
        ///A64: INS Vd.B[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vset_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_u8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vset_lane_u8", Category)]
        public object vset_lane_u8(object vector, byte index, byte data) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane)
        ///A32: VMOV.F32 Sd, Sm
        ///A64: INS Vd.S[lane], Vn.S[0]
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_f32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_f32", Category)]
        public object vsetq_lane_f32(object vector, byte index, float data) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, float, float, System.Runtime.Intrinsics.Vector128<float>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane)
        ///A32: VMOV.F64 Dd, Dm
        ///A64: INS Vd.D[lane], Vn.D[0]
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_f64)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_f64", Category)]
        public object vsetq_lane_f64(object vector, byte index, double data) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, double, double, System.Runtime.Intrinsics.Vector128<double>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane)
        ///A32: VMOV.16 Dd[lane], Rt
        ///A64: INS Vd.H[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_s16", Category)]
        public object vsetq_lane_s16(object vector, byte index, short data) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, short, short, System.Runtime.Intrinsics.Vector128<short>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane)
        ///A32: VMOV.32 Dd[lane], Rt
        ///A64: INS Vd.S[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_s32", Category)]
        public object vsetq_lane_s32(object vector, byte index, int data) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, int, int, System.Runtime.Intrinsics.Vector128<int>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane)
        ///A32: VMOV.64 Dd, Rt, Rt2
        ///A64: INS Vd.D[lane], Xn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s64)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_s64", Category)]
        public object vsetq_lane_s64(object vector, byte index, long data) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, long, long, System.Runtime.Intrinsics.Vector128<long>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane)
        ///A32: VMOV.8 Dd[lane], Rt
        ///A64: INS Vd.B[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_s8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_s8", Category)]
        public object vsetq_lane_s8(object vector, byte index, sbyte data) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, sbyte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane)
        ///A32: VMOV.16 Dd[lane], Rt
        ///A64: INS Vd.H[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u16)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_u16", Category)]
        public object vsetq_lane_u16(object vector, byte index, ushort data) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, ushort, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane)
        ///A32: VMOV.32 Dd[lane], Rt
        ///A64: INS Vd.S[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u32)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_u32", Category)]
        public object vsetq_lane_u32(object vector, byte index, uint data) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, uint, uint, System.Runtime.Intrinsics.Vector128<uint>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane)
        ///A32: VMOV.64 Dd, Rt, Rt2
        ///A64: INS Vd.D[lane], Xn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u64)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_u64", Category)]
        public object vsetq_lane_u64(object vector, byte index, ulong data) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, ulong, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane)
        ///A32: VMOV.8 Dd[lane], Rt
        ///A64: INS Vd.B[lane], Wn
        ///
        ///
        ///Instruction Documentation: [vsetq_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_u8)
        /// <param name="vector"></param>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("vsetq_lane_u8", Category)]
        public object vsetq_lane_u8(object vector, byte index, byte data) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(vector, index, data, System.Runtime.Intrinsics.Arm.AdvSimd.Insert);
        
        /// <summary>
        /// int16x4_t vshl_n_s16 (int16x4_t a, const int n)
        ///A32: VSHL.I16 Dd, Dm, #n
        ///A64: SHL Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_s16", Category)]
        public object vshl_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// int32x2_t vshl_n_s32 (int32x2_t a, const int n)
        ///A32: VSHL.I32 Dd, Dm, #n
        ///A64: SHL Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_s32", Category)]
        public object vshl_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// int64x1_t vshl_n_s64 (int64x1_t a, const int n)
        ///A32: VSHL.I64 Dd, Dm, #n
        ///A64: SHL Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_s64", Category)]
        public object vshl_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalScalar);
        
        /// <summary>
        /// int8x8_t vshl_n_s8 (int8x8_t a, const int n)
        ///A32: VSHL.I8 Dd, Dm, #n
        ///A64: SHL Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_s8", Category)]
        public object vshl_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n)
        ///A32: VSHL.I16 Dd, Dm, #n
        ///A64: SHL Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_u16", Category)]
        public object vshl_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n)
        ///A32: VSHL.I32 Dd, Dm, #n
        ///A64: SHL Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_u32", Category)]
        public object vshl_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n)
        ///A32: VSHL.I64 Dd, Dm, #n
        ///A64: SHL Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_u64", Category)]
        public object vshl_n_u64(object value, byte count) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalScalar);
        
        /// <summary>
        /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n)
        ///A32: VSHL.I8 Dd, Dm, #n
        ///A64: SHL Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vshl_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_n_u8", Category)]
        public object vshl_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VSHL.S16 Dd, Dn, Dm
        ///A64: SSHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vshl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_s16", Category)]
        public object vshl_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// int32x2_t vshl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VSHL.S32 Dd, Dn, Dm
        ///A64: SSHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vshl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_s32", Category)]
        public object vshl_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// int64x1_t vshl_s64 (int64x1_t a, int64x1_t b)
        ///A32: VSHL.S64 Dd, Dn, Dm
        ///A64: SSHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vshl_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_s64", Category)]
        public object vshl_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmeticScalar);
        
        /// <summary>
        /// int8x8_t vshl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VSHL.S8 Dd, Dn, Dm
        ///A64: SSHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vshl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_s8", Category)]
        public object vshl_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b)
        ///A32: VSHL.U16 Dd, Dn, Dm
        ///A64: USHL Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vshl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_u16", Category)]
        public object vshl_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b)
        ///A32: VSHL.U32 Dd, Dn, Dm
        ///A64: USHL Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vshl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_u32", Category)]
        public object vshl_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b)
        ///A32: VSHL.U64 Dd, Dn, Dm
        ///A64: USHL Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vshl_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_u64", Category)]
        public object vshl_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogicalScalar);
        
        /// <summary>
        /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b)
        ///A32: VSHL.U8 Dd, Dn, Dm
        ///A64: USHL Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vshl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshl_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshl_u8", Category)]
        public object vshl_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n)
        ///A32: VSHLL.S16 Qd, Dm+1, #n
        ///A64: SSHLL2 Vd.4S, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshll_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_high_n_s16", Category)]
        public object vshll_high_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper);
        
        /// <summary>
        /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n)
        ///A32: VSHLL.S32 Qd, Dm+1, #n
        ///A64: SSHLL2 Vd.2D, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshll_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_high_n_s32", Category)]
        public object vshll_high_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper);
        
        /// <summary>
        /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n)
        ///A32: VSHLL.S8 Qd, Dm+1, #n
        ///A64: SSHLL2 Vd.8H, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vshll_high_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_high_n_s8", Category)]
        public object vshll_high_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper);
        
        /// <summary>
        /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n)
        ///A32: VSHLL.U16 Qd, Dm+1, #n
        ///A64: USHLL2 Vd.4S, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshll_high_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_high_n_u16", Category)]
        public object vshll_high_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper);
        
        /// <summary>
        /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n)
        ///A32: VSHLL.U32 Qd, Dm+1, #n
        ///A64: USHLL2 Vd.2D, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshll_high_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_high_n_u32", Category)]
        public object vshll_high_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper);
        
        /// <summary>
        /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n)
        ///A32: VSHLL.U8 Qd, Dm+1, #n
        ///A64: USHLL2 Vd.8H, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vshll_high_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_high_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_high_n_u8", Category)]
        public object vshll_high_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper);
        
        /// <summary>
        /// int32x4_t vshll_n_s16 (int16x4_t a, const int n)
        ///A32: VSHLL.S16 Qd, Dm, #n
        ///A64: SSHLL Vd.4S, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vshll_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_n_s16", Category)]
        public object vshll_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower);
        
        /// <summary>
        /// int64x2_t vshll_n_s32 (int32x2_t a, const int n)
        ///A32: VSHLL.S32 Qd, Dm, #n
        ///A64: SSHLL Vd.2D, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vshll_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_n_s32", Category)]
        public object vshll_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower);
        
        /// <summary>
        /// int16x8_t vshll_n_s8 (int8x8_t a, const int n)
        ///A32: VSHLL.S8 Qd, Dm, #n
        ///A64: SSHLL Vd.8H, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vshll_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_n_s8", Category)]
        public object vshll_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower);
        
        /// <summary>
        /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n)
        ///A32: VSHLL.U16 Qd, Dm, #n
        ///A64: USHLL Vd.4S, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vshll_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_n_u16", Category)]
        public object vshll_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower);
        
        /// <summary>
        /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n)
        ///A32: VSHLL.U32 Qd, Dm, #n
        ///A64: USHLL Vd.2D, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vshll_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_n_u32", Category)]
        public object vshll_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower);
        
        /// <summary>
        /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n)
        ///A32: VSHLL.U8 Qd, Dm, #n
        ///A64: USHLL Vd.8H, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vshll_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshll_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshll_n_u8", Category)]
        public object vshll_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower);
        
        /// <summary>
        /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n)
        ///A32: VSHL.I16 Qd, Qm, #n
        ///A64: SHL Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_s16", Category)]
        public object vshlq_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n)
        ///A32: VSHL.I64 Qd, Qm, #n
        ///A64: SHL Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_s64", Category)]
        public object vshlq_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n)
        ///A32: VSHL.I8 Qd, Qm, #n
        ///A64: SHL Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_s8", Category)]
        public object vshlq_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n)
        ///A32: VSHL.I16 Qd, Qm, #n
        ///A64: SHL Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_u16", Category)]
        public object vshlq_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n)
        ///A32: VSHL.I32 Qd, Qm, #n
        ///A64: SHL Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_u32", Category)]
        public object vshlq_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n)
        ///A32: VSHL.I64 Qd, Qm, #n
        ///A64: SHL Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_u64", Category)]
        public object vshlq_n_u64(object value, byte count) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n)
        ///A32: VSHL.I8 Qd, Qm, #n
        ///A64: SHL Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vshlq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_n_u8", Category)]
        public object vshlq_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical);
        
        /// <summary>
        /// int16x8_t vshlq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VSHL.S16 Qd, Qn, Qm
        ///A64: SSHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vshlq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_s16", Category)]
        public object vshlq_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// int32x4_t vshlq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VSHL.S32 Qd, Qn, Qm
        ///A64: SSHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vshlq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_s32", Category)]
        public object vshlq_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// int64x2_t vshlq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VSHL.S64 Qd, Qn, Qm
        ///A64: SSHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vshlq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_s64", Category)]
        public object vshlq_s64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// int8x16_t vshlq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VSHL.S8 Qd, Qn, Qm
        ///A64: SSHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vshlq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_s8", Category)]
        public object vshlq_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftArithmetic);
        
        /// <summary>
        /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b)
        ///A32: VSHL.U16 Qd, Qn, Qm
        ///A64: USHL Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vshlq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_u16", Category)]
        public object vshlq_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b)
        ///A32: VSHL.U32 Qd, Qn, Qm
        ///A64: USHL Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vshlq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_u32", Category)]
        public object vshlq_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b)
        ///A32: VSHL.U64 Qd, Qn, Qm
        ///A64: USHL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vshlq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_u64", Category)]
        public object vshlq_u64(object value, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b)
        ///A32: VSHL.U8 Qd, Qn, Qm
        ///A64: USHL Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vshlq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshlq_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshlq_u8", Category)]
        public object vshlq_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLogical);
        
        /// <summary>
        /// int16x4_t vshr_n_s16 (int16x4_t a, const int n)
        ///A32: VSHR.S16 Dd, Dm, #n
        ///A64: SSHR Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_s16", Category)]
        public object vshr_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// int32x2_t vshr_n_s32 (int32x2_t a, const int n)
        ///A32: VSHR.S32 Dd, Dm, #n
        ///A64: SSHR Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_s32", Category)]
        public object vshr_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// int64x1_t vshr_n_s64 (int64x1_t a, const int n)
        ///A32: VSHR.S64 Dd, Dm, #n
        ///A64: SSHR Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_s64", Category)]
        public object vshr_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticScalar);
        
        /// <summary>
        /// int8x8_t vshr_n_s8 (int8x8_t a, const int n)
        ///A32: VSHR.S8 Dd, Dm, #n
        ///A64: SSHR Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_s8", Category)]
        public object vshr_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n)
        ///A32: VSHR.U16 Dd, Dm, #n
        ///A64: USHR Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_u16", Category)]
        public object vshr_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n)
        ///A32: VSHR.U32 Dd, Dm, #n
        ///A64: USHR Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_u32", Category)]
        public object vshr_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n)
        ///A32: VSHR.U64 Dd, Dm, #n
        ///A64: USHR Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_u64", Category)]
        public object vshr_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalScalar);
        
        /// <summary>
        /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n)
        ///A32: VSHR.U8 Dd, Dm, #n
        ///A64: USHR Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vshr_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshr_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshr_n_u8", Category)]
        public object vshr_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
        ///A32: VSHRN.I16 Dd+1, Qm, #n
        ///A64: SHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_high_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_s16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_high_n_s16", Category)]
        public object vshrn_high_n_s16(object lower, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
        ///A32: VSHRN.I32 Dd+1, Qm, #n
        ///A64: SHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_high_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_s32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_high_n_s32", Category)]
        public object vshrn_high_n_s32(object lower, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
        ///A32: VSHRN.I64 Dd+1, Qm, #n
        ///A64: SHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_high_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_s64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_high_n_s64", Category)]
        public object vshrn_high_n_s64(object lower, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
        ///A32: VSHRN.I16 Dd+1, Qm, #n
        ///A64: SHRN2 Vd.16B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_high_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_u16)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_high_n_u16", Category)]
        public object vshrn_high_n_u16(object lower, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
        ///A32: VSHRN.I32 Dd+1, Qm, #n
        ///A64: SHRN2 Vd.8H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_high_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_u32)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_high_n_u32", Category)]
        public object vshrn_high_n_u32(object lower, object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
        ///A32: VSHRN.I64 Dd+1, Qm, #n
        ///A64: SHRN2 Vd.4S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_high_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_high_n_u64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_high_n_u64", Category)]
        public object vshrn_high_n_u64(object lower, object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n)
        ///A32: VSHRN.I16 Dd, Qm, #n
        ///A64: SHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_n_s16", Category)]
        public object vshrn_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower);
        
        /// <summary>
        /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n)
        ///A32: VSHRN.I32 Dd, Qm, #n
        ///A64: SHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_n_s32", Category)]
        public object vshrn_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower);
        
        /// <summary>
        /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n)
        ///A32: VSHRN.I64 Dd, Qm, #n
        ///A64: SHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_n_s64", Category)]
        public object vshrn_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n)
        ///A32: VSHRN.I16 Dd, Qm, #n
        ///A64: SHRN Vd.8B, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_n_u16", Category)]
        public object vshrn_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n)
        ///A32: VSHRN.I32 Dd, Qm, #n
        ///A64: SHRN Vd.4H, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_n_u32", Category)]
        public object vshrn_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n)
        ///A32: VSHRN.I64 Dd, Qm, #n
        ///A64: SHRN Vd.2S, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshrn_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrn_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrn_n_u64", Category)]
        public object vshrn_n_u64(object value, byte count) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower);
        
        /// <summary>
        /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n)
        ///A32: VSHR.S16 Qd, Qm, #n
        ///A64: SSHR Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_s16", Category)]
        public object vshrq_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n)
        ///A32: VSHR.S32 Qd, Qm, #n
        ///A64: SSHR Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_s32", Category)]
        public object vshrq_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n)
        ///A32: VSHR.S64 Qd, Qm, #n
        ///A64: SSHR Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_s64", Category)]
        public object vshrq_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n)
        ///A32: VSHR.S8 Qd, Qm, #n
        ///A64: SSHR Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_s8", Category)]
        public object vshrq_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic);
        
        /// <summary>
        /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n)
        ///A32: VSHR.U16 Qd, Qm, #n
        ///A64: USHR Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_u16", Category)]
        public object vshrq_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
        ///A32: VSHR.U32 Qd, Qm, #n
        ///A64: USHR Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_u32", Category)]
        public object vshrq_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n)
        ///A32: VSHR.U64 Qd, Qm, #n
        ///A64: USHR Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_u64", Category)]
        public object vshrq_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n)
        ///A32: VSHR.U8 Qd, Qm, #n
        ///A64: USHR Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vshrq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vshrq_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vshrq_n_u8", Category)]
        public object vshrq_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical);
        
        /// <summary>
        /// float64x1_t vsqrt_f64 (float64x1_t a)
        ///A32: VSQRT.F64 Dd, Dm
        ///A64: FSQRT Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vsqrt_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrt_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vsqrt_f64", Category)]
        public object vsqrt_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SqrtScalar);
        
        /// <summary>
        /// float32_t vsqrts_f32 (float32_t a)
        ///A32: VSQRT.F32 Sd, Sm
        ///A64: FSQRT Sd, Sn The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vsqrts_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrts_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vsqrts_f32", Category)]
        public object vsqrts_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.SqrtScalar);
        
        /// <summary>
        /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n)
        ///A32: VSRA.S16 Dd, Dm, #n
        ///A64: SSRA Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_s16", Category)]
        public object vsra_n_s16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n)
        ///A32: VSRA.S32 Dd, Dm, #n
        ///A64: SSRA Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_s32", Category)]
        public object vsra_n_s32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n)
        ///A32: VSRA.S64 Dd, Dm, #n
        ///A64: SSRA Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_s64", Category)]
        public object vsra_n_s64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAddScalar);
        
        /// <summary>
        /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n)
        ///A32: VSRA.S8 Dd, Dm, #n
        ///A64: SSRA Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_s8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_s8", Category)]
        public object vsra_n_s8(object addend, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
        ///A32: VSRA.U16 Dd, Dm, #n
        ///A64: USRA Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_u16", Category)]
        public object vsra_n_u16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
        ///A32: VSRA.U32 Dd, Dm, #n
        ///A64: USRA Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_u32", Category)]
        public object vsra_n_u32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
        ///A32: VSRA.U64 Dd, Dm, #n
        ///A64: USRA Dd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_u64", Category)]
        public object vsra_n_u64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, long, System.Runtime.Intrinsics.Vector64<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAddScalar);
        
        /// <summary>
        /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
        ///A32: VSRA.U8 Dd, Dm, #n
        ///A64: USRA Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vsra_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsra_n_u8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsra_n_u8", Category)]
        public object vsra_n_u8(object addend, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n)
        ///A32: VSRA.S16 Qd, Qm, #n
        ///A64: SSRA Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_s16", Category)]
        public object vsraq_n_s16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
        ///A32: VSRA.S32 Qd, Qm, #n
        ///A64: SSRA Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_s32", Category)]
        public object vsraq_n_s32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n)
        ///A32: VSRA.S64 Qd, Qm, #n
        ///A64: SSRA Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_s64", Category)]
        public object vsraq_n_s64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n)
        ///A32: VSRA.S8 Qd, Qm, #n
        ///A64: SSRA Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_s8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_s8", Category)]
        public object vsraq_n_s8(object addend, object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd);
        
        /// <summary>
        /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
        ///A32: VSRA.U16 Qd, Qm, #n
        ///A64: USRA Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u16)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_u16", Category)]
        public object vsraq_n_u16(object addend, object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
        ///A32: VSRA.U32 Qd, Qm, #n
        ///A64: USRA Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u32)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_u32", Category)]
        public object vsraq_n_u32(object addend, object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
        ///A32: VSRA.U64 Qd, Qm, #n
        ///A64: USRA Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u64)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_u64", Category)]
        public object vsraq_n_u64(object addend, object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
        ///A32: VSRA.U8 Qd, Qm, #n
        ///A64: USRA Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vsraq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsraq_n_u8)
        /// <param name="addend"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vsraq_n_u8", Category)]
        public object vsraq_n_u8(object addend, object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(addend, value, count, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd);
        
        /// <summary>
        /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n))
        ///A32: VSRI.16 Dd, Dm, #n
        ///A64: SRI Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vsri_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsri_n_s16", Category)]
        public object vsri_n_s16(object left, object right, byte shift) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n))
        ///A32: VSRI.32 Dd, Dm, #n
        ///A64: SRI Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vsri_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsri_n_s32", Category)]
        public object vsri_n_s32(object left, object right, byte shift) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n))
        ///A32: VSRI.8 Dd, Dm, #n
        ///A64: SRI Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vsri_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsri_n_s8", Category)]
        public object vsri_n_s8(object left, object right, byte shift) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n))
        ///A32: VSRI.16 Dd, Dm, #n
        ///A64: SRI Vd.4H, Vn.4H, #n
        ///
        ///
        ///Instruction Documentation: [vsri_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsri_n_u16", Category)]
        public object vsri_n_u16(object left, object right, byte shift) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n))
        ///A32: VSRI.32 Dd, Dm, #n
        ///A64: SRI Vd.2S, Vn.2S, #n
        ///
        ///
        ///Instruction Documentation: [vsri_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsri_n_u32", Category)]
        public object vsri_n_u32(object left, object right, byte shift) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n))
        ///A32: VSRI.8 Dd, Dm, #n
        ///A64: SRI Vd.8B, Vn.8B, #n
        ///
        ///
        ///Instruction Documentation: [vsri_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsri_n_u8", Category)]
        public object vsri_n_u8(object left, object right, byte shift) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n))
        ///A32: VSRI.16 Qd, Qm, #n
        ///A64: SRI Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_s16", Category)]
        public object vsriq_n_s16(object left, object right, byte shift) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
        ///A32: VSRI.32 Qd, Qm, #n
        ///A64: SRI Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_s32", Category)]
        public object vsriq_n_s32(object left, object right, byte shift) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n))
        ///A32: VSRI.64 Qd, Qm, #n
        ///A64: SRI Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_s64", Category)]
        public object vsriq_n_s64(object left, object right, byte shift) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n))
        ///A32: VSRI.8 Qd, Qm, #n
        ///A64: SRI Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_s8", Category)]
        public object vsriq_n_s8(object left, object right, byte shift) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n))
        ///A32: VSRI.16 Qd, Qm, #n
        ///A64: SRI Vd.8H, Vn.8H, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_u16", Category)]
        public object vsriq_n_u16(object left, object right, byte shift) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
        ///A32: VSRI.32 Qd, Qm, #n
        ///A64: SRI Vd.4S, Vn.4S, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_u32", Category)]
        public object vsriq_n_u32(object left, object right, byte shift) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n))
        ///A32: VSRI.64 Qd, Qm, #n
        ///A64: SRI Vd.2D, Vn.2D, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_u64", Category)]
        public object vsriq_n_u64(object left, object right, byte shift) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n))
        ///A32: VSRI.8 Qd, Qm, #n
        ///A64: SRI Vd.16B, Vn.16B, #n
        ///
        ///
        ///Instruction Documentation: [vsriq_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsriq_n_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="shift"></param>
        /// </summary>
        [KalkExport("vsriq_n_u8", Category)]
        public object vsriq_n_u8(object left, object right, byte shift) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, shift, System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert);
        
        /// <summary>
        /// void vst1_f32 (float32_t * ptr, float32x2_t val)
        ///A32: VST1.32 { Dd }, [Rn]
        ///A64: ST1 { Vt.2S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f32)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_f32", Category)]
        public void vst1_f32(object address, object source) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector64<float>>(address, source, AdvSimd_Store2522);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<float>> AdvSimd_Store2522 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<float>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((float*)arg0, (System.Runtime.Intrinsics.Vector64<float>)arg1));
        /// <summary>
        /// void vst1_f64 (float64_t * ptr, float64x1_t val)
        ///A32: VST1.64 { Dd }, [Rn]
        ///A64: ST1 { Vt.1D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_f64)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_f64", Category)]
        public void vst1_f64(object address, object source) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector64<double>>(address, source, AdvSimd_Store2512);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<double>> AdvSimd_Store2512 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<double>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((double*)arg0, (System.Runtime.Intrinsics.Vector64<double>)arg1));
        /// <summary>
        /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane)
        ///A32: VST1.32 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_f32)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_f32", Category)]
        public void vst1_lane_f32(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2540);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<float>, byte> AdvSimd_StoreSelectedScalar2540 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<float>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((float*)arg0, (System.Runtime.Intrinsics.Vector64<float>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane)
        ///A32: VST1.16 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s16)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_s16", Category)]
        public void vst1_lane_s16(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2533);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<short>, byte> AdvSimd_StoreSelectedScalar2533 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<short>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((short*)arg0, (System.Runtime.Intrinsics.Vector64<short>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane)
        ///A32: VST1.32 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s32)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_s32", Category)]
        public void vst1_lane_s32(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2535);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<int>, byte> AdvSimd_StoreSelectedScalar2535 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<int>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((int*)arg0, (System.Runtime.Intrinsics.Vector64<int>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane)
        ///A32: VST1.8 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_s8)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_s8", Category)]
        public void vst1_lane_s8(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2538);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>, byte> AdvSimd_StoreSelectedScalar2538 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((sbyte*)arg0, (System.Runtime.Intrinsics.Vector64<sbyte>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane)
        ///A32: VST1.16 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u16)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_u16", Category)]
        public void vst1_lane_u16(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2542);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>, byte> AdvSimd_StoreSelectedScalar2542 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((ushort*)arg0, (System.Runtime.Intrinsics.Vector64<ushort>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane)
        ///A32: VST1.32 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u32)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_u32", Category)]
        public void vst1_lane_u32(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2544);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<uint>, byte> AdvSimd_StoreSelectedScalar2544 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<uint>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((uint*)arg0, (System.Runtime.Intrinsics.Vector64<uint>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_lane_u8 (uint8_t * ptr, uint8x8_t val, const int lane)
        ///A32: VST1.8 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_lane_u8)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1_lane_u8", Category)]
        public void vst1_lane_u8(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2530);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<byte>, byte> AdvSimd_StoreSelectedScalar2530 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<byte>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((byte*)arg0, (System.Runtime.Intrinsics.Vector64<byte>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1_s16 (int16_t * ptr, int16x4_t val)
        ///A32: VST1.16 { Dd }, [Rn]
        ///A64: ST1 {Vt.4H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s16)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_s16", Category)]
        public void vst1_s16(object address, object source) => ProcessAction<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector64<short>>(address, source, AdvSimd_Store2514);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<short>> AdvSimd_Store2514 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<short>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((short*)arg0, (System.Runtime.Intrinsics.Vector64<short>)arg1));
        /// <summary>
        /// void vst1_s32 (int32_t * ptr, int32x2_t val)
        ///A32: VST1.32 { Dd }, [Rn]
        ///A64: ST1 { Vt.2S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s32)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_s32", Category)]
        public void vst1_s32(object address, object source) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector64<int>>(address, source, AdvSimd_Store2516);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<int>> AdvSimd_Store2516 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<int>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((int*)arg0, (System.Runtime.Intrinsics.Vector64<int>)arg1));
        /// <summary>
        /// void vst1_s64 (int64_t * ptr, int64x1_t val)
        ///A32: VST1.64 { Dd }, [Rn]
        ///A64: ST1 { Vt.1D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s64)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_s64", Category)]
        public void vst1_s64(object address, object source) => ProcessAction<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector64<long>>(address, source, AdvSimd_Store2518);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<long>> AdvSimd_Store2518 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<long>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((long*)arg0, (System.Runtime.Intrinsics.Vector64<long>)arg1));
        /// <summary>
        /// void vst1_s8 (int8_t * ptr, int8x8_t val)
        ///A32: VST1.8 { Dd }, [Rn]
        ///A64: ST1 { Vt.8B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_s8)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_s8", Category)]
        public void vst1_s8(object address, object source) => ProcessAction<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(address, source, AdvSimd_Store2520);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>> AdvSimd_Store2520 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<sbyte>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((sbyte*)arg0, (System.Runtime.Intrinsics.Vector64<sbyte>)arg1));
        /// <summary>
        /// void vst1_u16 (uint16_t * ptr, uint16x4_t val)
        ///A32: VST1.16 { Dd }, [Rn]
        ///A64: ST1 { Vt.4H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u16)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_u16", Category)]
        public void vst1_u16(object address, object source) => ProcessAction<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(address, source, AdvSimd_Store2524);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>> AdvSimd_Store2524 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<ushort>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((ushort*)arg0, (System.Runtime.Intrinsics.Vector64<ushort>)arg1));
        /// <summary>
        /// void vst1_u32 (uint32_t * ptr, uint32x2_t val)
        ///A32: VST1.32 { Dd }, [Rn]
        ///A64: ST1 { Vt.2S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u32)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_u32", Category)]
        public void vst1_u32(object address, object source) => ProcessAction<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector64<uint>>(address, source, AdvSimd_Store2526);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<uint>> AdvSimd_Store2526 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<uint>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((uint*)arg0, (System.Runtime.Intrinsics.Vector64<uint>)arg1));
        /// <summary>
        /// void vst1_u64 (uint64_t * ptr, uint64x1_t val)
        ///A32: VST1.64 { Dd }, [Rn]
        ///A64: ST1 { Vt.1D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u64)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_u64", Category)]
        public void vst1_u64(object address, object source) => ProcessAction<IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(address, source, AdvSimd_Store2528);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<ulong>> AdvSimd_Store2528 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<ulong>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((ulong*)arg0, (System.Runtime.Intrinsics.Vector64<ulong>)arg1));
        /// <summary>
        /// void vst1_u8 (uint8_t * ptr, uint8x8_t val)
        ///A32: VST1.8 { Dd }, [Rn]
        ///A64: ST1 { Vt.8B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1_u8)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1_u8", Category)]
        public void vst1_u8(object address, object source) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector64<byte>>(address, source, AdvSimd_Store2510);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector64<byte>> AdvSimd_Store2510 = new Action<IntPtr, System.Runtime.Intrinsics.Vector64<byte>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((byte*)arg0, (System.Runtime.Intrinsics.Vector64<byte>)arg1));
        /// <summary>
        /// void vst1q_f32 (float32_t * ptr, float32x4_t val)
        ///A32: VST1.32 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.4S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f32)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_f32", Category)]
        public void vst1q_f32(object address, object source) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(address, source, AdvSimd_Store2521);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> AdvSimd_Store2521 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// void vst1q_f64 (float64_t * ptr, float64x2_t val)
        ///A32: VST1.64 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.2D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_f64)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_f64", Category)]
        public void vst1q_f64(object address, object source) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(address, source, AdvSimd_Store2511);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> AdvSimd_Store2511 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane)
        ///A32: VST1.32 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_f32)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_f32", Category)]
        public void vst1q_lane_f32(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2539);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>, byte> AdvSimd_StoreSelectedScalar2539 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane)
        ///A32: VSTR.64 Dd, [Rn]
        ///A64: ST1 { Vt.D }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_f64)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_f64", Category)]
        public void vst1q_lane_f64(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2531);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>, byte> AdvSimd_StoreSelectedScalar2531 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane)
        ///A32: VST1.16 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s16)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_s16", Category)]
        public void vst1q_lane_s16(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2532);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<short>, byte> AdvSimd_StoreSelectedScalar2532 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<short>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((short*)arg0, (System.Runtime.Intrinsics.Vector128<short>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane)
        ///A32: VST1.32 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s32)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_s32", Category)]
        public void vst1q_lane_s32(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2534);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte> AdvSimd_StoreSelectedScalar2534 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((int*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane)
        ///A32: VSTR.64 Dd, [Rn]
        ///A64: ST1 { Vt.D }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s64)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_s64", Category)]
        public void vst1q_lane_s64(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2536);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte> AdvSimd_StoreSelectedScalar2536 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((long*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane)
        ///A32: VST1.8 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_s8)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_s8", Category)]
        public void vst1q_lane_s8(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2537);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>, byte> AdvSimd_StoreSelectedScalar2537 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((sbyte*)arg0, (System.Runtime.Intrinsics.Vector128<sbyte>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane)
        ///A32: VST1.16 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.H }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u16)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_u16", Category)]
        public void vst1q_lane_u16(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2541);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<ushort>, byte> AdvSimd_StoreSelectedScalar2541 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<ushort>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((ushort*)arg0, (System.Runtime.Intrinsics.Vector128<ushort>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane)
        ///A32: VST1.32 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.S }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u32)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_u32", Category)]
        public void vst1q_lane_u32(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2543);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<uint>, byte> AdvSimd_StoreSelectedScalar2543 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<uint>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((uint*)arg0, (System.Runtime.Intrinsics.Vector128<uint>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane)
        ///A32: VSTR.64 Dd, [Rn]
        ///A64: ST1 { Vt.D }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u64)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_u64", Category)]
        public void vst1q_lane_u64(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2545);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>, byte> AdvSimd_StoreSelectedScalar2545 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((ulong*)arg0, (System.Runtime.Intrinsics.Vector128<ulong>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane)
        ///A32: VST1.8 { Dd[index] }, [Rn]
        ///A64: ST1 { Vt.B }[index], [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_lane_u8)
        /// <param name="address"></param>
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vst1q_lane_u8", Category)]
        public void vst1q_lane_u8(object address, object value, byte index) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte>(address, value, index, AdvSimd_StoreSelectedScalar2529);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>, byte> AdvSimd_StoreSelectedScalar2529 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>, byte>((arg0, arg1, arg2) => System.Runtime.Intrinsics.Arm.AdvSimd.StoreSelectedScalar((byte*)arg0, (System.Runtime.Intrinsics.Vector128<byte>)arg1, (byte)arg2));
        /// <summary>
        /// void vst1q_s16 (int16_t * ptr, int16x8_t val)
        ///A32: VST1.16 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.8H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s16)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_s16", Category)]
        public void vst1q_s16(object address, object source) => ProcessAction<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector128<short>>(address, source, AdvSimd_Store2513);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<short>> AdvSimd_Store2513 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<short>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((short*)arg0, (System.Runtime.Intrinsics.Vector128<short>)arg1));
        /// <summary>
        /// void vst1q_s32 (int32_t * ptr, int32x4_t val)
        ///A32: VST1.32 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.4S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s32)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_s32", Category)]
        public void vst1q_s32(object address, object source) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(address, source, AdvSimd_Store2515);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>> AdvSimd_Store2515 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((int*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1));
        /// <summary>
        /// void vst1q_s64 (int64_t * ptr, int64x2_t val)
        ///A32: VST1.64 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.2D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s64)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_s64", Category)]
        public void vst1q_s64(object address, object source) => ProcessAction<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(address, source, AdvSimd_Store2517);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>> AdvSimd_Store2517 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((long*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1));
        /// <summary>
        /// void vst1q_s8 (int8_t * ptr, int8x16_t val)
        ///A32: VST1.8 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.16B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_s8)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_s8", Category)]
        public void vst1q_s8(object address, object source) => ProcessAction<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(address, source, AdvSimd_Store2519);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>> AdvSimd_Store2519 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((sbyte*)arg0, (System.Runtime.Intrinsics.Vector128<sbyte>)arg1));
        /// <summary>
        /// void vst1q_u16 (uint16_t * ptr, uint16x8_t val)
        ///A32: VST1.16 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.8H }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u16)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_u16", Category)]
        public void vst1q_u16(object address, object source) => ProcessAction<IntPtr, IntPtr, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(address, source, AdvSimd_Store2523);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<ushort>> AdvSimd_Store2523 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<ushort>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((ushort*)arg0, (System.Runtime.Intrinsics.Vector128<ushort>)arg1));
        /// <summary>
        /// void vst1q_u32 (uint32_t * ptr, uint32x4_t val)
        ///A32: VST1.32 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.4S }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u32)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_u32", Category)]
        public void vst1q_u32(object address, object source) => ProcessAction<IntPtr, IntPtr, uint, System.Runtime.Intrinsics.Vector128<uint>>(address, source, AdvSimd_Store2525);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<uint>> AdvSimd_Store2525 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<uint>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((uint*)arg0, (System.Runtime.Intrinsics.Vector128<uint>)arg1));
        /// <summary>
        /// void vst1q_u64 (uint64_t * ptr, uint64x2_t val)
        ///A32: VST1.64 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.2D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u64)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_u64", Category)]
        public void vst1q_u64(object address, object source) => ProcessAction<IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(address, source, AdvSimd_Store2527);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>> AdvSimd_Store2527 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((ulong*)arg0, (System.Runtime.Intrinsics.Vector128<ulong>)arg1));
        /// <summary>
        /// void vst1q_u8 (uint8_t * ptr, uint8x16_t val)
        ///A32: VST1.8 { Dd, Dd+1 }, [Rn]
        ///A64: ST1 { Vt.16B }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vst1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vst1q_u8)
        /// <param name="address"></param>
        /// <param name="source"></param>
        /// </summary>
        [KalkExport("vst1q_u8", Category)]
        public void vst1q_u8(object address, object source) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(address, source, AdvSimd_Store2509);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> AdvSimd_Store2509 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0, arg1) => System.Runtime.Intrinsics.Arm.AdvSimd.Store((byte*)arg0, (System.Runtime.Intrinsics.Vector128<byte>)arg1));
        /// <summary>
        /// float32x2_t vsub_f32 (float32x2_t a, float32x2_t b)
        ///A32: VSUB.F32 Dd, Dn, Dm
        ///A64: FSUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsub_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_f32", Category)]
        public object vsub_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// float64x1_t vsub_f64 (float64x1_t a, float64x1_t b)
        ///A32: VSUB.F64 Dd, Dn, Dm
        ///A64: FSUB Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vsub_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_f64", Category)]
        public object vsub_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractScalar);
        
        /// <summary>
        /// int16x4_t vsub_s16 (int16x4_t a, int16x4_t b)
        ///A32: VSUB.I16 Dd, Dn, Dm
        ///A64: SUB Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vsub_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_s16", Category)]
        public object vsub_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int32x2_t vsub_s32 (int32x2_t a, int32x2_t b)
        ///A32: VSUB.I32 Dd, Dn, Dm
        ///A64: SUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsub_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_s32", Category)]
        public object vsub_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int64x1_t vsub_s64 (int64x1_t a, int64x1_t b)
        ///A32: VSUB.I64 Dd, Dn, Dm
        ///A64: SUB Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vsub_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_s64", Category)]
        public object vsub_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractScalar);
        
        /// <summary>
        /// int8x8_t vsub_s8 (int8x8_t a, int8x8_t b)
        ///A32: VSUB.I8 Dd, Dn, Dm
        ///A64: SUB Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vsub_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_s8", Category)]
        public object vsub_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint16x4_t vsub_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VSUB.I16 Dd, Dn, Dm
        ///A64: SUB Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vsub_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_u16", Category)]
        public object vsub_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint32x2_t vsub_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VSUB.I32 Dd, Dn, Dm
        ///A64: SUB Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsub_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_u32", Category)]
        public object vsub_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint64x1_t vsub_u64 (uint64x1_t a, uint64x1_t b)
        ///A32: VSUB.I64 Dd, Dn, Dm
        ///A64: SUB Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vsub_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_u64", Category)]
        public object vsub_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractScalar);
        
        /// <summary>
        /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VSUB.I8 Dd, Dn, Dm
        ///A64: SUB Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vsub_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsub_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsub_u8", Category)]
        public object vsub_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b)
        ///A32: VSUBHN.I16 Dd+1, Qn, Qm
        ///A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubhn_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_s16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_high_s16", Category)]
        public object vsubhn_high_s16(object lower, object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingUpper);
        
        /// <summary>
        /// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b)
        ///A32: VSUBHN.I32 Dd+1, Qn, Qm
        ///A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubhn_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_s32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_high_s32", Category)]
        public object vsubhn_high_s32(object lower, object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingUpper);
        
        /// <summary>
        /// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b)
        ///A32: VSUBHN.I64 Dd+1, Qn, Qm
        ///A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubhn_high_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_s64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_high_s64", Category)]
        public object vsubhn_high_s64(object lower, object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingUpper);
        
        /// <summary>
        /// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b)
        ///A32: VSUBHN.I16 Dd+1, Qn, Qm
        ///A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubhn_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_u16)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_high_u16", Category)]
        public object vsubhn_high_u16(object lower, object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingUpper);
        
        /// <summary>
        /// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b)
        ///A32: VSUBHN.I32 Dd+1, Qn, Qm
        ///A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubhn_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_u32)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_high_u32", Category)]
        public object vsubhn_high_u32(object lower, object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingUpper);
        
        /// <summary>
        /// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b)
        ///A32: VSUBHN.I64 Dd+1, Qn, Qm
        ///A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubhn_high_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_high_u64)
        /// <param name="lower"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_high_u64", Category)]
        public object vsubhn_high_u64(object lower, object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>>(lower, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingUpper);
        
        /// <summary>
        /// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b)
        ///A32: VSUBHN.I16 Dd, Qn, Qm
        ///A64: SUBHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubhn_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_s16", Category)]
        public object vsubhn_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingLower);
        
        /// <summary>
        /// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b)
        ///A32: VSUBHN.I32 Dd, Qn, Qm
        ///A64: SUBHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubhn_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_s32", Category)]
        public object vsubhn_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingLower);
        
        /// <summary>
        /// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b)
        ///A32: VSUBHN.I64 Dd, Qn, Qm
        ///A64: SUBHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubhn_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_s64", Category)]
        public object vsubhn_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingLower);
        
        /// <summary>
        /// uint8x8_t vsubhn_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VSUBHN.I16 Dd, Qn, Qm
        ///A64: SUBHN Vd.8B, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubhn_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_u16", Category)]
        public object vsubhn_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingLower);
        
        /// <summary>
        /// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VSUBHN.I32 Dd, Qn, Qm
        ///A64: SUBHN Vd.4H, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubhn_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_u32", Category)]
        public object vsubhn_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingLower);
        
        /// <summary>
        /// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VSUBHN.I64 Dd, Qn, Qm
        ///A64: SUBHN Vd.2S, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubhn_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubhn_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubhn_u64", Category)]
        public object vsubhn_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractHighNarrowingLower);
        
        /// <summary>
        /// int32x4_t vsubl_high_s16 (int16x8_t a, int16x8_t b)
        ///A32: VSUBL.S16 Qd, Dn+1, Dm+1
        ///A64: SSUBL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubl_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_high_s16", Category)]
        public object vsubl_high_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// int64x2_t vsubl_high_s32 (int32x4_t a, int32x4_t b)
        ///A32: VSUBL.S32 Qd, Dn+1, Dm+1
        ///A64: SSUBL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubl_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_high_s32", Category)]
        public object vsubl_high_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// int16x8_t vsubl_high_s8 (int8x16_t a, int8x16_t b)
        ///A32: VSUBL.S8 Qd, Dn+1, Dm+1
        ///A64: SSUBL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vsubl_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_high_s8", Category)]
        public object vsubl_high_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// uint32x4_t vsubl_high_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VSUBL.U16 Qd, Dn+1, Dm+1
        ///A64: USUBL2 Vd.4S, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubl_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_high_u16", Category)]
        public object vsubl_high_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// uint64x2_t vsubl_high_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VSUBL.U32 Qd, Dn+1, Dm+1
        ///A64: USUBL2 Vd.2D, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubl_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_high_u32", Category)]
        public object vsubl_high_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// uint16x8_t vsubl_high_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VSUBL.U8 Qd, Dn+1, Dm+1
        ///A64: USUBL2 Vd.8H, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vsubl_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_high_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_high_u8", Category)]
        public object vsubl_high_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// int32x4_t vsubl_s16 (int16x4_t a, int16x4_t b)
        ///A32: VSUBL.S16 Qd, Dn, Dm
        ///A64: SSUBL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vsubl_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_s16", Category)]
        public object vsubl_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// int64x2_t vsubl_s32 (int32x2_t a, int32x2_t b)
        ///A32: VSUBL.S32 Qd, Dn, Dm
        ///A64: SSUBL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsubl_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_s32", Category)]
        public object vsubl_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// int16x8_t vsubl_s8 (int8x8_t a, int8x8_t b)
        ///A32: VSUBL.S8 Qd, Dn, Dm
        ///A64: SSUBL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vsubl_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_s8", Category)]
        public object vsubl_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint32x4_t vsubl_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VSUBL.U16 Qd, Dn, Dm
        ///A64: USUBL Vd.4S, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vsubl_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_u16", Category)]
        public object vsubl_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint64x2_t vsubl_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VSUBL.U32 Qd, Dn, Dm
        ///A64: USUBL Vd.2D, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsubl_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_u32", Category)]
        public object vsubl_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint16x8_t vsubl_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VSUBL.U8 Qd, Dn, Dm
        ///A64: USUBL Vd.8H, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vsubl_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubl_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubl_u8", Category)]
        public object vsubl_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// float32x4_t vsubq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VSUB.F32 Qd, Qn, Qm
        ///A64: FSUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_f32", Category)]
        public object vsubq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int16x8_t vsubq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VSUB.I16 Qd, Qn, Qm
        ///A64: SUB Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_s16", Category)]
        public object vsubq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int32x4_t vsubq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VSUB.I32 Qd, Qn, Qm
        ///A64: SUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_s32", Category)]
        public object vsubq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int64x2_t vsubq_s64 (int64x2_t a, int64x2_t b)
        ///A32: VSUB.I64 Qd, Qn, Qm
        ///A64: SUB Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_s64", Category)]
        public object vsubq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// int8x16_t vsubq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VSUB.I8 Qd, Qn, Qm
        ///A64: SUB Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vsubq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_s8", Category)]
        public object vsubq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint16x8_t vsubq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VSUB.I16 Qd, Qn, Qm
        ///A64: SUB Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_u16", Category)]
        public object vsubq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint32x4_t vsubq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VSUB.I32 Qd, Qn, Qm
        ///A64: SUB Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_u32", Category)]
        public object vsubq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint64x2_t vsubq_u64 (uint64x2_t a, uint64x2_t b)
        ///A32: VSUB.I64 Qd, Qn, Qm
        ///A64: SUB Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_u64", Category)]
        public object vsubq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// uint8x16_t vsubq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VSUB.I8 Qd, Qn, Qm
        ///A64: SUB Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vsubq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_u8", Category)]
        public object vsubq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Subtract);
        
        /// <summary>
        /// float32_t vsubs_f32 (float32_t a, float32_t b)
        ///A32: VSUB.F32 Sd, Sn, Sm
        ///A64: FSUB Sd, Sn, Sm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vsubs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubs_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubs_f32", Category)]
        public object vsubs_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractScalar);
        
        /// <summary>
        /// int32x4_t vsubw_high_s16 (int32x4_t a, int16x8_t b)
        ///A32: VSUBW.S16 Qd, Qn, Dm+1
        ///A64: SSUBW2 Vd.4S, Vn.4S, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubw_high_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_high_s16", Category)]
        public object vsubw_high_s16(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// int64x2_t vsubw_high_s32 (int64x2_t a, int32x4_t b)
        ///A32: VSUBW.S32 Qd, Qn, Dm+1
        ///A64: SSUBW2 Vd.2D, Vn.2D, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubw_high_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_high_s32", Category)]
        public object vsubw_high_s32(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// int16x8_t vsubw_high_s8 (int16x8_t a, int8x16_t b)
        ///A32: VSUBW.S8 Qd, Qn, Dm+1
        ///A64: SSUBW2 Vd.8H, Vn.8H, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vsubw_high_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_high_s8", Category)]
        public object vsubw_high_s8(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// uint32x4_t vsubw_high_u16 (uint32x4_t a, uint16x8_t b)
        ///A32: VSUBW.U16 Qd, Qn, Dm+1
        ///A64: USUBW2 Vd.4S, Vn.4S, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vsubw_high_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_high_u16", Category)]
        public object vsubw_high_u16(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// uint64x2_t vsubw_high_u32 (uint64x2_t a, uint32x4_t b)
        ///A32: VSUBW.U32 Qd, Qn, Dm+1
        ///A64: USUBW2 Vd.2D, Vn.2D, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsubw_high_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_high_u32", Category)]
        public object vsubw_high_u32(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// uint16x8_t vsubw_high_u8 (uint16x8_t a, uint8x16_t b)
        ///A32: VSUBW.U8 Qd, Qn, Dm+1
        ///A64: USUBW2 Vd.8H, Vn.8H, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vsubw_high_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_high_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_high_u8", Category)]
        public object vsubw_high_u8(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningUpper);
        
        /// <summary>
        /// int32x4_t vsubw_s16 (int32x4_t a, int16x4_t b)
        ///A32: VSUBW.S16 Qd, Qn, Dm
        ///A64: SSUBW Vd.4S, Vn.4S, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vsubw_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_s16", Category)]
        public object vsubw_s16(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// int64x2_t vsubw_s32 (int64x2_t a, int32x2_t b)
        ///A32: VSUBW.S32 Qd, Qn, Dm
        ///A64: SSUBW Vd.2D, Vn.2D, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsubw_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_s32", Category)]
        public object vsubw_s32(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector64<int>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// int16x8_t vsubw_s8 (int16x8_t a, int8x8_t b)
        ///A32: VSUBW.S8 Qd, Qn, Dm
        ///A64: SSUBW Vd.8H, Vn.8H, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vsubw_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_s8", Category)]
        public object vsubw_s8(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint32x4_t vsubw_u16 (uint32x4_t a, uint16x4_t b)
        ///A32: VSUBW.U16 Qd, Qn, Dm
        ///A64: USUBW Vd.4S, Vn.4S, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vsubw_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_u16", Category)]
        public object vsubw_u16(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint64x2_t vsubw_u32 (uint64x2_t a, uint32x2_t b)
        ///A32: VSUBW.U32 Qd, Qn, Dm
        ///A64: USUBW Vd.2D, Vn.2D, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vsubw_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_u32", Category)]
        public object vsubw_u32(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, uint, System.Runtime.Intrinsics.Vector64<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint16x8_t vsubw_u8 (uint16x8_t a, uint8x8_t b)
        ///A32: VSUBW.U8 Qd, Qn, Dm
        ///A64: USUBW Vd.8H, Vn.8H, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vsubw_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubw_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubw_u8", Category)]
        public object vsubw_u8(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.SubtractWideningLower);
        
        /// <summary>
        /// uint32x2_t vtst_f32 (float32x2_t a, float32x2_t b)
        ///A32: VTST.32 Dd, Dn, Dm
        ///A64: CMTST Vd.2S, Vn.2S, Vm.2S The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vtst_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_f32", Category)]
        public object vtst_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint16x4_t vtst_s16 (int16x4_t a, int16x4_t b)
        ///A32: VTST.16 Dd, Dn, Dm
        ///A64: CMTST Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vtst_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_s16", Category)]
        public object vtst_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint32x2_t vtst_s32 (int32x2_t a, int32x2_t b)
        ///A32: VTST.32 Dd, Dn, Dm
        ///A64: CMTST Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtst_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_s32", Category)]
        public object vtst_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint8x8_t vtst_s8 (int8x8_t a, int8x8_t b)
        ///A32: VTST.8 Dd, Dn, Dm
        ///A64: CMTST Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vtst_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_s8", Category)]
        public object vtst_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint16x4_t vtst_u16 (uint16x4_t a, uint16x4_t b)
        ///A32: VTST.16 Dd, Dn, Dm
        ///A64: CMTST Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vtst_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_u16", Category)]
        public object vtst_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint32x2_t vtst_u32 (uint32x2_t a, uint32x2_t b)
        ///A32: VTST.32 Dd, Dn, Dm
        ///A64: CMTST Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtst_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_u32", Category)]
        public object vtst_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint8x8_t vtst_u8 (uint8x8_t a, uint8x8_t b)
        ///A32: VTST.8 Dd, Dn, Dm
        ///A64: CMTST Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vtst_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_u8", Category)]
        public object vtst_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint32x4_t vtstq_f32 (float32x4_t a, float32x4_t b)
        ///A32: VTST.32 Qd, Qn, Qm
        ///A64: CMTST Vd.4S, Vn.4S, Vm.4S The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vtstq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_f32", Category)]
        public object vtstq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint16x8_t vtstq_s16 (int16x8_t a, int16x8_t b)
        ///A32: VTST.16 Qd, Qn, Qm
        ///A64: CMTST Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vtstq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_s16", Category)]
        public object vtstq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint32x4_t vtstq_s32 (int32x4_t a, int32x4_t b)
        ///A32: VTST.32 Qd, Qn, Qm
        ///A64: CMTST Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtstq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_s32", Category)]
        public object vtstq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint8x16_t vtstq_s8 (int8x16_t a, int8x16_t b)
        ///A32: VTST.8 Qd, Qn, Qm
        ///A64: CMTST Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vtstq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_s8", Category)]
        public object vtstq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint16x8_t vtstq_u16 (uint16x8_t a, uint16x8_t b)
        ///A32: VTST.16 Qd, Qn, Qm
        ///A64: CMTST Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vtstq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_u16", Category)]
        public object vtstq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint32x4_t vtstq_u32 (uint32x4_t a, uint32x4_t b)
        ///A32: VTST.32 Qd, Qn, Qm
        ///A64: CMTST Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtstq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_u32", Category)]
        public object vtstq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
        /// <summary>
        /// uint8x16_t vtstq_u8 (uint8x16_t a, uint8x16_t b)
        ///A32: VTST.8 Qd, Qn, Qm
        ///A64: CMTST Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vtstq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_u8", Category)]
        public object vtstq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.CompareTest);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class AdvSimdArm64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / ADVSIMD";

        /// <summary>
        /// float64x1_t vabd_f64 (float64x1_t a, float64x1_t b)
        ///A64: FABD Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vabd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabd_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabd_f64", Category)]
        public object vabd_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteDifferenceScalar);
        
        /// <summary>
        /// float64x2_t vabdq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FABD Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vabdq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabdq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabdq_f64", Category)]
        public object vabdq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteDifference);
        
        /// <summary>
        /// float32_t vabds_f32 (float32_t a, float32_t b)
        ///A64: FABD Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vabds_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabds_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vabds_f32", Category)]
        public object vabds_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteDifferenceScalar);
        
        /// <summary>
        /// int64x1_t vabs_s64 (int64x1_t a)
        ///A64: ABS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vabs_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabs_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabs_s64", Category)]
        public object vabs_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsScalar);
        
        /// <summary>
        /// float64x2_t vabsq_f64 (float64x2_t a)
        ///A64: FABS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vabsq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabsq_f64", Category)]
        public object vabsq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Abs);
        
        /// <summary>
        /// int64x2_t vabsq_s64 (int64x2_t a)
        ///A64: ABS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vabsq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vabsq_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vabsq_s64", Category)]
        public object vabsq_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Abs);
        
        /// <summary>
        /// int32_t vaddlv_s16 (int16x4_t a)
        ///A64: SADDLV Sd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vaddlv_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlv_s16", Category)]
        public object vaddlv_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// int16_t vaddlv_s8 (int8x8_t a)
        ///A64: SADDLV Hd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vaddlv_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlv_s8", Category)]
        public object vaddlv_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// uint32_t vaddlv_u16 (uint16x4_t a)
        ///A64: UADDLV Sd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vaddlv_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlv_u16", Category)]
        public object vaddlv_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// uint16_t vaddlv_u8 (uint8x8_t a)
        ///A64: UADDLV Hd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vaddlv_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlv_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlv_u8", Category)]
        public object vaddlv_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// int32_t vaddlvq_s16 (int16x8_t a)
        ///A64: SADDLV Sd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vaddlvq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlvq_s16", Category)]
        public object vaddlvq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// int64_t vaddlvq_s32 (int32x4_t a)
        ///A64: SADDLV Dd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vaddlvq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlvq_s32", Category)]
        public object vaddlvq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// int16_t vaddlvq_s8 (int8x16_t a)
        ///A64: SADDLV Hd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaddlvq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlvq_s8", Category)]
        public object vaddlvq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// uint32_t vaddlvq_u16 (uint16x8_t a)
        ///A64: UADDLV Sd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vaddlvq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlvq_u16", Category)]
        public object vaddlvq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// uint64_t vaddlvq_u32 (uint32x4_t a)
        ///A64: UADDLV Dd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vaddlvq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlvq_u32", Category)]
        public object vaddlvq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// uint16_t vaddlvq_u8 (uint8x16_t a)
        ///A64: UADDLV Hd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaddlvq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddlvq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddlvq_u8", Category)]
        public object vaddlvq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcrossWidening);
        
        /// <summary>
        /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FADD Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vaddq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vaddq_f64", Category)]
        public object vaddq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Add);
        
        /// <summary>
        /// int16_t vaddv_s16 (int16x4_t a)
        ///A64: ADDV Hd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vaddv_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddv_s16", Category)]
        public object vaddv_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// int8_t vaddv_s8 (int8x8_t a)
        ///A64: ADDV Bd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vaddv_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddv_s8", Category)]
        public object vaddv_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// uint16_t vaddv_u16 (uint16x4_t a)
        ///A64: ADDV Hd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vaddv_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddv_u16", Category)]
        public object vaddv_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// uint8_t vaddv_u8 (uint8x8_t a)
        ///A64: ADDV Bd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vaddv_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddv_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddv_u8", Category)]
        public object vaddv_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// int16_t vaddvq_s16 (int16x8_t a)
        ///A64: ADDV Hd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vaddvq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddvq_s16", Category)]
        public object vaddvq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// int32_t vaddvq_s32 (int32x4_t a)
        ///A64: ADDV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vaddvq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddvq_s32", Category)]
        public object vaddvq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// int8_t vaddvq_s8 (int8x16_t a)
        ///A64: ADDV Bd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaddvq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddvq_s8", Category)]
        public object vaddvq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// uint16_t vaddvq_u16 (uint16x8_t a)
        ///A64: ADDV Hd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vaddvq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddvq_u16", Category)]
        public object vaddvq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// uint32_t vaddvq_u32 (uint32x4_t a)
        ///A64: ADDV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vaddvq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddvq_u32", Category)]
        public object vaddvq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// uint8_t vaddvq_u8 (uint8x16_t a)
        ///A64: ADDV Bd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaddvq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddvq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaddvq_u8", Category)]
        public object vaddvq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddAcross);
        
        /// <summary>
        /// uint64x1_t vcage_f64 (float64x1_t a, float64x1_t b)
        ///A64: FACGE Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcage_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcage_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcage_f64", Category)]
        public object vcage_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareGreaterThanOrEqualScalar);
        
        /// <summary>
        /// uint64x2_t vcageq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FACGE Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcageq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcageq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcageq_f64", Category)]
        public object vcageq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32_t vcages_f32 (float32_t a, float32_t b)
        ///A64: FACGE Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcages_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcages_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcages_f32", Category)]
        public object vcages_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareGreaterThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcagt_f64 (float64x1_t a, float64x1_t b)
        ///A64: FACGT Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcagt_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagt_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcagt_f64", Category)]
        public object vcagt_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareGreaterThanScalar);
        
        /// <summary>
        /// uint64x2_t vcagtq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FACGT Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcagtq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagtq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcagtq_f64", Category)]
        public object vcagtq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareGreaterThan);
        
        /// <summary>
        /// uint32_t vcagts_f32 (float32_t a, float32_t b)
        ///A64: FACGT Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcagts_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcagts_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcagts_f32", Category)]
        public object vcagts_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareGreaterThanScalar);
        
        /// <summary>
        /// uint64x1_t vcale_f64 (float64x1_t a, float64x1_t b)
        ///A64: FACGE Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcale_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcale_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcale_f64", Category)]
        public object vcale_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareLessThanOrEqualScalar);
        
        /// <summary>
        /// uint64x2_t vcaleq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FACGE Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcaleq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaleq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcaleq_f64", Category)]
        public object vcaleq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareLessThanOrEqual);
        
        /// <summary>
        /// uint32_t vcales_f32 (float32_t a, float32_t b)
        ///A64: FACGE Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcales_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcales_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcales_f32", Category)]
        public object vcales_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareLessThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcalt_f64 (float64x1_t a, float64x1_t b)
        ///A64: FACGT Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcalt_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalt_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcalt_f64", Category)]
        public object vcalt_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareLessThanScalar);
        
        /// <summary>
        /// uint64x2_t vcaltq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FACGT Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcaltq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcaltq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcaltq_f64", Category)]
        public object vcaltq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareLessThan);
        
        /// <summary>
        /// uint32_t vcalts_f32 (float32_t a, float32_t b)
        ///A64: FACGT Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcalts_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcalts_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcalts_f32", Category)]
        public object vcalts_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsoluteCompareLessThanScalar);
        
        /// <summary>
        /// uint64x1_t vceq_f64 (float64x1_t a, float64x1_t b)
        ///A64: FCMEQ Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vceq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_f64", Category)]
        public object vceq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqualScalar);
        
        /// <summary>
        /// uint64x1_t vceq_s64 (int64x1_t a, int64x1_t b)
        ///A64: CMEQ Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vceq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_s64", Category)]
        public object vceq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqualScalar);
        
        /// <summary>
        /// uint64x1_t vceq_u64 (uint64x1_t a, uint64x1_t b)
        ///A64: CMEQ Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vceq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceq_u64", Category)]
        public object vceq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqualScalar);
        
        /// <summary>
        /// uint64x2_t vceqq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FCMEQ Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vceqq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_f64", Category)]
        public object vceqq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqual);
        
        /// <summary>
        /// uint64x2_t vceqq_s64 (int64x2_t a, int64x2_t b)
        ///A64: CMEQ Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vceqq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_s64", Category)]
        public object vceqq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqual);
        
        /// <summary>
        /// uint64x2_t vceqq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: CMEQ Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vceqq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqq_u64", Category)]
        public object vceqq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqual);
        
        /// <summary>
        /// uint32_t vceqs_f32 (float32_t a, float32_t b)
        ///A64: FCMEQ Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vceqs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vceqs_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vceqs_f32", Category)]
        public object vceqs_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcge_f64 (float64x1_t a, float64x1_t b)
        ///A64: FCMGE Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcge_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_f64", Category)]
        public object vcge_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcge_s64 (int64x1_t a, int64x1_t b)
        ///A64: CMGE Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcge_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_s64", Category)]
        public object vcge_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcge_u64 (uint64x1_t a, uint64x1_t b)
        ///A64: CMHS Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcge_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcge_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcge_u64", Category)]
        public object vcge_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqualScalar);
        
        /// <summary>
        /// uint64x2_t vcgeq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FCMGE Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcgeq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_f64", Category)]
        public object vcgeq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint64x2_t vcgeq_s64 (int64x2_t a, int64x2_t b)
        ///A64: CMGE Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcgeq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_s64", Category)]
        public object vcgeq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint64x2_t vcgeq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: CMHS Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcgeq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgeq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgeq_u64", Category)]
        public object vcgeq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// uint32_t vcges_f32 (float32_t a, float32_t b)
        ///A64: FCMGE Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcges_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcges_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcges_f32", Category)]
        public object vcges_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcgt_f64 (float64x1_t a, float64x1_t b)
        ///A64: FCMGT Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcgt_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_f64", Category)]
        public object vcgt_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanScalar);
        
        /// <summary>
        /// uint64x1_t vcgt_s64 (int64x1_t a, int64x1_t b)
        ///A64: CMGT Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcgt_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_s64", Category)]
        public object vcgt_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanScalar);
        
        /// <summary>
        /// uint64x1_t vcgt_u64 (uint64x1_t a, uint64x1_t b)
        ///A64: CMHI Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcgt_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgt_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgt_u64", Category)]
        public object vcgt_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanScalar);
        
        /// <summary>
        /// uint64x2_t vcgtq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FCMGT Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcgtq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_f64", Category)]
        public object vcgtq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThan);
        
        /// <summary>
        /// uint64x2_t vcgtq_s64 (int64x2_t a, int64x2_t b)
        ///A64: CMGT Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcgtq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_s64", Category)]
        public object vcgtq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThan);
        
        /// <summary>
        /// uint64x2_t vcgtq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: CMHI Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcgtq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgtq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgtq_u64", Category)]
        public object vcgtq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThan);
        
        /// <summary>
        /// uint32_t vcgts_f32 (float32_t a, float32_t b)
        ///A64: FCMGT Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcgts_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcgts_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcgts_f32", Category)]
        public object vcgts_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareGreaterThanScalar);
        
        /// <summary>
        /// uint64x1_t vcle_f64 (float64x1_t a, float64x1_t b)
        ///A64: FCMGE Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcle_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_f64", Category)]
        public object vcle_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcle_s64 (int64x1_t a, int64x1_t b)
        ///A64: CMGE Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcle_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_s64", Category)]
        public object vcle_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vcle_u64 (uint64x1_t a, uint64x1_t b)
        ///A64: CMHS Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vcle_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcle_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcle_u64", Category)]
        public object vcle_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqualScalar);
        
        /// <summary>
        /// uint64x2_t vcleq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FCMGE Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcleq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_f64", Category)]
        public object vcleq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint64x2_t vcleq_s64 (int64x2_t a, int64x2_t b)
        ///A64: CMGE Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcleq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_s64", Category)]
        public object vcleq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint64x2_t vcleq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: CMHS Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcleq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcleq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcleq_u64", Category)]
        public object vcleq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqual);
        
        /// <summary>
        /// uint32_t vcles_f32 (float32_t a, float32_t b)
        ///A64: FCMGE Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vcles_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcles_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcles_f32", Category)]
        public object vcles_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanOrEqualScalar);
        
        /// <summary>
        /// uint64x1_t vclt_f64 (float64x1_t a, float64x1_t b)
        ///A64: FCMGT Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vclt_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_f64", Category)]
        public object vclt_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanScalar);
        
        /// <summary>
        /// uint64x1_t vclt_s64 (int64x1_t a, int64x1_t b)
        ///A64: CMGT Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vclt_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_s64", Category)]
        public object vclt_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanScalar);
        
        /// <summary>
        /// uint64x1_t vclt_u64 (uint64x1_t a, uint64x1_t b)
        ///A64: CMHI Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vclt_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclt_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclt_u64", Category)]
        public object vclt_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanScalar);
        
        /// <summary>
        /// uint64x2_t vcltq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FCMGT Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcltq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_f64", Category)]
        public object vcltq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThan);
        
        /// <summary>
        /// uint64x2_t vcltq_s64 (int64x2_t a, int64x2_t b)
        ///A64: CMGT Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcltq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_s64", Category)]
        public object vcltq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThan);
        
        /// <summary>
        /// uint64x2_t vcltq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: CMHI Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vcltq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcltq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vcltq_u64", Category)]
        public object vcltq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThan);
        
        /// <summary>
        /// uint32_t vclts_f32 (float32_t a, float32_t b)
        ///A64: FCMGT Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vclts_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vclts_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vclts_f32", Category)]
        public object vclts_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareLessThanScalar);
        
        /// <summary>
        /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_f32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_f32", Category)]
        public object vcopy_lane_f32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_s16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_s16", Category)]
        public object vcopy_lane_s16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_s32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_s32", Category)]
        public object vcopy_lane_s32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_s8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_s8", Category)]
        public object vcopy_lane_s8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_u16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_u16", Category)]
        public object vcopy_lane_u16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_u32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_u32", Category)]
        public object vcopy_lane_u32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_lane_u8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_lane_u8", Category)]
        public object vcopy_lane_u8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_f32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_f32", Category)]
        public object vcopy_laneq_f32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_s16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_s16", Category)]
        public object vcopy_laneq_s16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_s32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_s32", Category)]
        public object vcopy_laneq_s32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_s8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_s8", Category)]
        public object vcopy_laneq_s8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_u16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_u16", Category)]
        public object vcopy_laneq_u16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_u32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_u32", Category)]
        public object vcopy_laneq_u32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopy_laneq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopy_laneq_u8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopy_laneq_u8", Category)]
        public object vcopy_laneq_u8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_f32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_f32", Category)]
        public object vcopyq_lane_f32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_s16", Category)]
        public object vcopyq_lane_s16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_s32", Category)]
        public object vcopyq_lane_s32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_s8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_s8", Category)]
        public object vcopyq_lane_s8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_u16", Category)]
        public object vcopyq_lane_u16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_u32", Category)]
        public object vcopyq_lane_u32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_lane_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_lane_u8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_lane_u8", Category)]
        public object vcopyq_lane_u8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_f32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_f32", Category)]
        public object vcopyq_laneq_f32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2)
        ///A64: INS Vd.D[lane1], Vn.D[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_f64)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_f64", Category)]
        public object vcopyq_laneq_f64(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_s16", Category)]
        public object vcopyq_laneq_s16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_s32", Category)]
        public object vcopyq_laneq_s32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2)
        ///A64: INS Vd.D[lane1], Vn.D[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s64)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_s64", Category)]
        public object vcopyq_laneq_s64(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_s8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_s8", Category)]
        public object vcopyq_laneq_s8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2)
        ///A64: INS Vd.H[lane1], Vn.H[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u16)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_u16", Category)]
        public object vcopyq_laneq_u16(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2)
        ///A64: INS Vd.S[lane1], Vn.S[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u32)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_u32", Category)]
        public object vcopyq_laneq_u32(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector128<uint>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2)
        ///A64: INS Vd.D[lane1], Vn.D[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u64)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_u64", Category)]
        public object vcopyq_laneq_u64(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2)
        ///A64: INS Vd.B[lane1], Vn.B[lane2]
        ///
        ///
        ///Instruction Documentation: [vcopyq_laneq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcopyq_laneq_u8)
        /// <param name="result"></param>
        /// <param name="resultIndex"></param>
        /// <param name="value"></param>
        /// <param name="valueIndex"></param>
        /// </summary>
        [KalkExport("vcopyq_laneq_u8", Category)]
        public object vcopyq_laneq_u8(object result, byte resultIndex, object value, byte valueIndex) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(result, resultIndex, value, valueIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.InsertSelectedScalar);
        
        /// <summary>
        /// float32x2_t vcvt_f32_f64 (float64x2_t a)
        ///A64: FCVTN Vd.2S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvt_f32_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f32_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_f32_f64", Category)]
        public object vcvt_f32_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToSingleLower);
        
        /// <summary>
        /// float64x2_t vcvt_f64_f32 (float32x2_t a)
        ///A64: FCVTL Vd.2D, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vcvt_f64_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f64_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_f64_f32", Category)]
        public object vcvt_f64_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToDouble);
        
        /// <summary>
        /// float64x1_t vcvt_f64_s64 (int64x1_t a)
        ///A64: SCVTF Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvt_f64_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f64_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_f64_s64", Category)]
        public object vcvt_f64_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToDoubleScalar);
        
        /// <summary>
        /// float64x1_t vcvt_f64_u64 (uint64x1_t a)
        ///A64: UCVTF Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvt_f64_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_f64_u64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_f64_u64", Category)]
        public object vcvt_f64_u64(object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToDoubleScalar);
        
        /// <summary>
        /// float32x4_t vcvt_high_f32_f64 (float32x2_t r, float64x2_t a)
        ///A64: FCVTN2 Vd.4S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvt_high_f32_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_high_f32_f64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_high_f32_f64", Category)]
        public object vcvt_high_f32_f64(object lower, object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector128<float>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToSingleUpper);
        
        /// <summary>
        /// float64x2_t vcvt_high_f64_f32 (float32x4_t a)
        ///A64: FCVTL2 Vd.2D, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vcvt_high_f64_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_high_f64_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_high_f64_f32", Category)]
        public object vcvt_high_f64_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToDoubleUpper);
        
        /// <summary>
        /// int64x1_t vcvt_s64_f64 (float64x1_t a)
        ///A64: FCVTZS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvt_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_s64_f64", Category)]
        public object vcvt_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToZeroScalar);
        
        /// <summary>
        /// uint64x1_t vcvt_u64_f64 (float64x1_t a)
        ///A64: FCVTZU Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvt_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvt_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvt_u64_f64", Category)]
        public object vcvt_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToZeroScalar);
        
        /// <summary>
        /// int64x1_t vcvta_s64_f64 (float64x1_t a)
        ///A64: FCVTAS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvta_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvta_s64_f64", Category)]
        public object vcvta_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundAwayFromZeroScalar);
        
        /// <summary>
        /// uint64x1_t vcvta_u64_f64 (float64x1_t a)
        ///A64: FCVTAU Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvta_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvta_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvta_u64_f64", Category)]
        public object vcvta_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundAwayFromZeroScalar);
        
        /// <summary>
        /// int64x2_t vcvtaq_s64_f64 (float64x2_t a)
        ///A64: FCVTAS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtaq_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtaq_s64_f64", Category)]
        public object vcvtaq_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundAwayFromZero);
        
        /// <summary>
        /// uint64x2_t vcvtaq_u64_f64 (float64x2_t a)
        ///A64: FCVTAU Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtaq_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtaq_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtaq_u64_f64", Category)]
        public object vcvtaq_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundAwayFromZero);
        
        /// <summary>
        /// int64x1_t vcvtm_s64_f64 (float64x1_t a)
        ///A64: FCVTMS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvtm_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtm_s64_f64", Category)]
        public object vcvtm_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// uint64x1_t vcvtm_u64_f64 (float64x1_t a)
        ///A64: FCVTMU Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvtm_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtm_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtm_u64_f64", Category)]
        public object vcvtm_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// int64x2_t vcvtmq_s64_f64 (float64x2_t a)
        ///A64: FCVTMS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtmq_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtmq_s64_f64", Category)]
        public object vcvtmq_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToNegativeInfinity);
        
        /// <summary>
        /// uint64x2_t vcvtmq_u64_f64 (float64x2_t a)
        ///A64: FCVTMU Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtmq_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtmq_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtmq_u64_f64", Category)]
        public object vcvtmq_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToNegativeInfinity);
        
        /// <summary>
        /// int64x1_t vcvtn_s64_f64 (float64x1_t a)
        ///A64: FCVTNS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvtn_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtn_s64_f64", Category)]
        public object vcvtn_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToEvenScalar);
        
        /// <summary>
        /// uint64x1_t vcvtn_u64_f64 (float64x1_t a)
        ///A64: FCVTNU Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvtn_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtn_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtn_u64_f64", Category)]
        public object vcvtn_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToEvenScalar);
        
        /// <summary>
        /// int64x2_t vcvtnq_s64_f64 (float64x2_t a)
        ///A64: FCVTNS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtnq_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtnq_s64_f64", Category)]
        public object vcvtnq_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToEven);
        
        /// <summary>
        /// uint64x2_t vcvtnq_u64_f64 (float64x2_t a)
        ///A64: FCVTNU Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtnq_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtnq_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtnq_u64_f64", Category)]
        public object vcvtnq_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToEven);
        
        /// <summary>
        /// int64x1_t vcvtp_s64_f64 (float64x1_t a)
        ///A64: FCVTPS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvtp_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtp_s64_f64", Category)]
        public object vcvtp_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// uint64x1_t vcvtp_u64_f64 (float64x1_t a)
        ///A64: FCVTPU Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vcvtp_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtp_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtp_u64_f64", Category)]
        public object vcvtp_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// int64x2_t vcvtpq_s64_f64 (float64x2_t a)
        ///A64: FCVTPS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtpq_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtpq_s64_f64", Category)]
        public object vcvtpq_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToPositiveInfinity);
        
        /// <summary>
        /// uint64x2_t vcvtpq_u64_f64 (float64x2_t a)
        ///A64: FCVTPU Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtpq_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtpq_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtpq_u64_f64", Category)]
        public object vcvtpq_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToPositiveInfinity);
        
        /// <summary>
        /// float64x2_t vcvtq_f64_s64 (int64x2_t a)
        ///A64: SCVTF Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtq_f64_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f64_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_f64_s64", Category)]
        public object vcvtq_f64_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToDouble);
        
        /// <summary>
        /// float64x2_t vcvtq_f64_u64 (uint64x2_t a)
        ///A64: UCVTF Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtq_f64_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_f64_u64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_f64_u64", Category)]
        public object vcvtq_f64_u64(object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToDouble);
        
        /// <summary>
        /// int64x2_t vcvtq_s64_f64 (float64x2_t a)
        ///A64: FCVTZS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtq_s64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_s64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_s64_f64", Category)]
        public object vcvtq_s64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToInt64RoundToZero);
        
        /// <summary>
        /// uint64x2_t vcvtq_u64_f64 (float64x2_t a)
        ///A64: FCVTZU Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtq_u64_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtq_u64_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtq_u64_f64", Category)]
        public object vcvtq_u64_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToUInt64RoundToZero);
        
        /// <summary>
        /// float32x2_t vcvtx_f32_f64 (float64x2_t a)
        ///A64: FCVTXN Vd.2S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtx_f32_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtx_f32_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtx_f32_f64", Category)]
        public object vcvtx_f32_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToSingleRoundToOddLower);
        
        /// <summary>
        /// float32x4_t vcvtx_high_f32_f64 (float32x2_t r, float64x2_t a)
        ///A64: FCVTXN2 Vd.4S, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vcvtx_high_f32_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcvtx_high_f32_f64)
        /// <param name="lower"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vcvtx_high_f32_f64", Category)]
        public object vcvtx_high_f32_f64(object lower, object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector128<float>>(lower, value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ConvertToSingleRoundToOddUpper);
        
        /// <summary>
        /// float32x2_t vdiv_f32 (float32x2_t a, float32x2_t b)
        ///A64: FDIV Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vdiv_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdiv_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vdiv_f32", Category)]
        public object vdiv_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Divide);
        
        /// <summary>
        /// float32x4_t vdivq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FDIV Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vdivq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vdivq_f32", Category)]
        public object vdivq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Divide);
        
        /// <summary>
        /// float64x2_t vdivq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FDIV Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vdivq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdivq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vdivq_f64", Category)]
        public object vdivq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Divide);
        
        /// <summary>
        /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane)
        ///A64: DUP Vd.2D, Vn.D[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_f64)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_laneq_f64", Category)]
        public object vdupq_laneq_f64(object value, byte index) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane)
        ///A64: DUP Vd.2D, Vn.D[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_laneq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_s64)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_laneq_s64", Category)]
        public object vdupq_laneq_s64(object value, byte index) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane)
        ///A64: DUP Vd.2D, Vn.D[index]
        ///
        ///
        ///Instruction Documentation: [vdupq_laneq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_laneq_u64)
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("vdupq_laneq_u64", Category)]
        public object vdupq_laneq_u64(object value, byte index) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, byte, byte, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(value, index, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.DuplicateSelectedScalarToVector128);
        
        /// <summary>
        /// float64x2_t vdupq_n_f64 (float64_t value)
        ///A64: DUP Vd.2D, Vn.D[0]
        ///
        ///
        ///Instruction Documentation: [vdupq_n_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_f64", Category)]
        public object vdupq_n_f64(double value) => (object)ProcessFunc<double, double, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.DuplicateToVector128);
        
        /// <summary>
        /// int64x2_t vdupq_n_s64 (int64_t value)
        ///A64: DUP Vd.2D, Rn
        ///
        ///
        ///Instruction Documentation: [vdupq_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vdupq_n_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vdupq_n_s64", Category)]
        public object vdupq_n_s64(long value) => (object)ProcessFunc<long, long, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.DuplicateToVector128);
        
        /// <summary>
        /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
        ///A64: FMLA Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfma_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_lane_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfma_lane_f32", Category)]
        public object vfma_lane_f32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
        ///A64: FMLA Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfma_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_laneq_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfma_laneq_f32", Category)]
        public object vfma_laneq_f32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vfma_n_f32 (float32x2_t a, float32x2_t b, float32_t n)
        ///A64: FMLA Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vfma_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfma_n_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfma_n_f32", Category)]
        public object vfma_n_f32(object addend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddByScalar);
        
        /// <summary>
        /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane)
        ///A64: FMLA Dd, Dn, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vfmad_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmad_laneq_f64)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmad_laneq_f64", Category)]
        public object vfmad_laneq_f64(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector64<double>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddScalarBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vfmaq_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
        ///A64: FMLA Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vfmaq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_f64)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmaq_f64", Category)]
        public object vfmaq_f64(object addend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAdd);
        
        /// <summary>
        /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
        ///A64: FMLA Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmaq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_lane_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmaq_lane_f32", Category)]
        public object vfmaq_lane_f32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
        ///A64: FMLA Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmaq_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_laneq_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmaq_laneq_f32", Category)]
        public object vfmaq_laneq_f32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane)
        ///A64: FMLA Vd.2D, Vn.2D, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vfmaq_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_laneq_f64)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmaq_laneq_f64", Category)]
        public object vfmaq_laneq_f64(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vfmaq_n_f32 (float32x4_t a, float32x4_t b, float32_t n)
        ///A64: FMLA Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vfmaq_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_n_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmaq_n_f32", Category)]
        public object vfmaq_n_f32(object addend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddByScalar);
        
        /// <summary>
        /// float64x2_t vfmaq_n_f64 (float64x2_t a, float64x2_t b, float64_t n)
        ///A64: FMLA Vd.2D, Vn.2D, Vm.D[0]
        ///
        ///
        ///Instruction Documentation: [vfmaq_n_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmaq_n_f64)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmaq_n_f64", Category)]
        public object vfmaq_n_f64(object addend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>>(addend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddByScalar);
        
        /// <summary>
        /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane)
        ///A64: FMLA Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmas_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmas_lane_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmas_lane_f32", Category)]
        public object vfmas_lane_f32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddScalarBySelectedScalar);
        
        /// <summary>
        /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane)
        ///A64: FMLA Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmas_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmas_laneq_f32)
        /// <param name="addend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmas_laneq_f32", Category)]
        public object vfmas_laneq_f32(object addend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(addend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplyAddScalarBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
        ///A64: FMLS Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfms_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_lane_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfms_lane_f32", Category)]
        public object vfms_lane_f32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
        ///A64: FMLS Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfms_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_laneq_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfms_laneq_f32", Category)]
        public object vfms_laneq_f32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vfms_n_f32 (float32x2_t a, float32x2_t b, float32_t n)
        ///A64: FMLS Vd.2S, Vn.2S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vfms_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfms_n_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfms_n_f32", Category)]
        public object vfms_n_f32(object minuend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractByScalar);
        
        /// <summary>
        /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane)
        ///A64: FMLS Dd, Dn, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vfmsd_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsd_laneq_f64)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmsd_laneq_f64", Category)]
        public object vfmsd_laneq_f64(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector64<double>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractScalarBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
        ///A64: FMLS Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vfmsq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_f64)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmsq_f64", Category)]
        public object vfmsq_f64(object minuend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtract);
        
        /// <summary>
        /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
        ///A64: FMLS Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmsq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_lane_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmsq_lane_f32", Category)]
        public object vfmsq_lane_f32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
        ///A64: FMLS Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmsq_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_laneq_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmsq_laneq_f32", Category)]
        public object vfmsq_laneq_f32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane)
        ///A64: FMLS Vd.2D, Vn.2D, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vfmsq_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_laneq_f64)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmsq_laneq_f64", Category)]
        public object vfmsq_laneq_f64(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vfmsq_n_f32 (float32x4_t a, float32x4_t b, float32_t n)
        ///A64: FMLS Vd.4S, Vn.4S, Vm.S[0]
        ///
        ///
        ///Instruction Documentation: [vfmsq_n_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_n_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmsq_n_f32", Category)]
        public object vfmsq_n_f32(object minuend, object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractByScalar);
        
        /// <summary>
        /// float64x2_t vfmsq_n_f64 (float64x2_t a, float64x2_t b, float64_t n)
        ///A64: FMLS Vd.2D, Vn.2D, Vm.D[0]
        ///
        ///
        ///Instruction Documentation: [vfmsq_n_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmsq_n_f64)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vfmsq_n_f64", Category)]
        public object vfmsq_n_f64(object minuend, object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>>(minuend, left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractByScalar);
        
        /// <summary>
        /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane)
        ///A64: FMLS Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmss_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmss_lane_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmss_lane_f32", Category)]
        public object vfmss_lane_f32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractScalarBySelectedScalar);
        
        /// <summary>
        /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane)
        ///A64: FMLS Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vfmss_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmss_laneq_f32)
        /// <param name="minuend"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vfmss_laneq_f32", Category)]
        public object vfmss_laneq_f32(object minuend, object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(minuend, left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.FusedMultiplySubtractScalarBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vld1q_dup_f64 (float64_t const * ptr)
        ///A64: LD1R { Vt.2D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_f64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_f64", Category)]
        public object vld1q_dup_f64(object address) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(address, AdvSimdArm64_LoadAndReplicateToVector1282889);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>> AdvSimdArm64_LoadAndReplicateToVector1282889 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.LoadAndReplicateToVector128((double*)arg0));
        /// <summary>
        /// int64x2_t vld1q_dup_s64 (int64_t const * ptr)
        ///A64: LD1R { Vt.2D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_s64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_s64", Category)]
        public object vld1q_dup_s64(object address) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(address, AdvSimdArm64_LoadAndReplicateToVector1282890);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>> AdvSimdArm64_LoadAndReplicateToVector1282890 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.LoadAndReplicateToVector128((long*)arg0));
        /// <summary>
        /// uint64x2_t vld1q_dup_u64 (uint64_t const * ptr)
        ///A64: LD1R { Vt.2D }, [Xn]
        ///
        ///
        ///Instruction Documentation: [vld1q_dup_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vld1q_dup_u64)
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("vld1q_dup_u64", Category)]
        public object vld1q_dup_u64(object address) => (object)ProcessFunc<IntPtr, IntPtr, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(address, AdvSimdArm64_LoadAndReplicateToVector1282891);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>> AdvSimdArm64_LoadAndReplicateToVector1282891 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<ulong>>((arg0) => System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.LoadAndReplicateToVector128((ulong*)arg0));
        /// <summary>
        /// float64x1_t vmax_f64 (float64x1_t a, float64x1_t b)
        ///A64: FMAX Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vmax_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmax_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmax_f64", Category)]
        public object vmax_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxScalar);
        
        /// <summary>
        /// float64x2_t vmaxnmq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMAXNM Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vmaxnmq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxnmq_f64", Category)]
        public object vmaxnmq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumber);
        
        /// <summary>
        /// float32_t vmaxnmvq_f32 (float32x4_t a)
        ///A64: FMAXNMV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmaxnmvq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxnmvq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxnmvq_f32", Category)]
        public object vmaxnmvq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumberAcross);
        
        /// <summary>
        /// float64x2_t vmaxq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMAX Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vmaxq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxq_f64", Category)]
        public object vmaxq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Max);
        
        /// <summary>
        /// float32_t vmaxs_f32 (float32_t a, float32_t b)
        ///A64: FMAX Sd, Sn, Sm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmaxs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxs_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmaxs_f32", Category)]
        public object vmaxs_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxScalar);
        
        /// <summary>
        /// int16_t vmaxv_s16 (int16x4_t a)
        ///A64: SMAXV Hd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vmaxv_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxv_s16", Category)]
        public object vmaxv_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// int8_t vmaxv_s8 (int8x8_t a)
        ///A64: SMAXV Bd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmaxv_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxv_s8", Category)]
        public object vmaxv_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// uint16_t vmaxv_u16 (uint16x4_t a)
        ///A64: UMAXV Hd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vmaxv_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxv_u16", Category)]
        public object vmaxv_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// uint8_t vmaxv_u8 (uint8x8_t a)
        ///A64: UMAXV Bd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vmaxv_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxv_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxv_u8", Category)]
        public object vmaxv_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// float32_t vmaxvq_f32 (float32x4_t a)
        ///A64: FMAXV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmaxvq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_f32", Category)]
        public object vmaxvq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// int16_t vmaxvq_s16 (int16x8_t a)
        ///A64: SMAXV Hd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmaxvq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_s16", Category)]
        public object vmaxvq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// int32_t vmaxvq_s32 (int32x4_t a)
        ///A64: SMAXV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmaxvq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_s32", Category)]
        public object vmaxvq_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// int8_t vmaxvq_s8 (int8x16_t a)
        ///A64: SMAXV Bd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmaxvq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_s8", Category)]
        public object vmaxvq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// uint16_t vmaxvq_u16 (uint16x8_t a)
        ///A64: UMAXV Hd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vmaxvq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_u16", Category)]
        public object vmaxvq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// uint32_t vmaxvq_u32 (uint32x4_t a)
        ///A64: UMAXV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vmaxvq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_u32", Category)]
        public object vmaxvq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// uint8_t vmaxvq_u8 (uint8x16_t a)
        ///A64: UMAXV Bd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vmaxvq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmaxvq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vmaxvq_u8", Category)]
        public object vmaxvq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxAcross);
        
        /// <summary>
        /// float64x1_t vmin_f64 (float64x1_t a, float64x1_t b)
        ///A64: FMIN Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vmin_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmin_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmin_f64", Category)]
        public object vmin_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinScalar);
        
        /// <summary>
        /// float64x2_t vminnmq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMINNM Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vminnmq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminnmq_f64", Category)]
        public object vminnmq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumber);
        
        /// <summary>
        /// float32_t vminnmvq_f32 (float32x4_t a)
        ///A64: FMINNMV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vminnmvq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminnmvq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminnmvq_f32", Category)]
        public object vminnmvq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumberAcross);
        
        /// <summary>
        /// float64x2_t vminq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMIN Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vminq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vminq_f64", Category)]
        public object vminq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Min);
        
        /// <summary>
        /// float32_t vmins_f32 (float32_t a, float32_t b)
        ///A64: FMIN Sd, Sn, Sm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vmins_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmins_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmins_f32", Category)]
        public object vmins_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinScalar);
        
        /// <summary>
        /// int16_t vminv_s16 (int16x4_t a)
        ///A64: SMINV Hd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vminv_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminv_s16", Category)]
        public object vminv_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// int8_t vminv_s8 (int8x8_t a)
        ///A64: SMINV Bd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vminv_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminv_s8", Category)]
        public object vminv_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// uint16_t vminv_u16 (uint16x4_t a)
        ///A64: UMINV Hd, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vminv_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminv_u16", Category)]
        public object vminv_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// uint8_t vminv_u8 (uint8x8_t a)
        ///A64: UMINV Bd, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vminv_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminv_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminv_u8", Category)]
        public object vminv_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// float32_t vminvq_f32 (float32x4_t a)
        ///A64: FMINV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vminvq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminvq_f32", Category)]
        public object vminvq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// int16_t vminvq_s16 (int16x8_t a)
        ///A64: SMINV Hd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vminvq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminvq_s16", Category)]
        public object vminvq_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// int8_t vminvq_s8 (int8x16_t a)
        ///A64: SMINV Bd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vminvq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminvq_s8", Category)]
        public object vminvq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// uint16_t vminvq_u16 (uint16x8_t a)
        ///A64: UMINV Hd, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vminvq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_u16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminvq_u16", Category)]
        public object vminvq_u16(object value) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// uint32_t vminvq_u32 (uint32x4_t a)
        ///A64: UMINV Sd, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vminvq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_u32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminvq_u32", Category)]
        public object vminvq_u32(object value) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// uint8_t vminvq_u8 (uint8x16_t a)
        ///A64: UMINV Bd, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vminvq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vminvq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vminvq_u8", Category)]
        public object vminvq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinAcross);
        
        /// <summary>
        /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane)
        ///A64: FMUL Dd, Dn, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vmuld_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmuld_laneq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmuld_laneq_f64", Category)]
        public object vmuld_laneq_f64(object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyScalarBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vmulq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMUL Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vmulq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_f64", Category)]
        public object vmulq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Multiply);
        
        /// <summary>
        /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane)
        ///A64: FMUL Vd.2D, Vn.2D, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vmulq_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_laneq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulq_laneq_f64", Category)]
        public object vmulq_laneq_f64(object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vmulq_n_f64 (float64x2_t a, float64_t b)
        ///A64: FMUL Vd.2D, Vn.2D, Vm.D[0]
        ///
        ///
        ///Instruction Documentation: [vmulq_n_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_n_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulq_n_f64", Category)]
        public object vmulq_n_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyByScalar);
        
        /// <summary>
        /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b)
        ///A64: FMULX Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vmulx_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulx_f32", Category)]
        public object vmulx_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtended);
        
        /// <summary>
        /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b)
        ///A64: FMULX Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vmulx_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulx_f64", Category)]
        public object vmulx_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedScalar);
        
        /// <summary>
        /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane)
        ///A64: FMULX Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulx_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_lane_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulx_lane_f32", Category)]
        public object vmulx_lane_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedBySelectedScalar);
        
        /// <summary>
        /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane)
        ///A64: FMULX Vd.2S, Vn.2S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulx_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulx_laneq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulx_laneq_f32", Category)]
        public object vmulx_laneq_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedBySelectedScalar);
        
        /// <summary>
        /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane)
        ///A64: FMULX Dd, Dn, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vmulxd_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxd_laneq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulxd_laneq_f64", Category)]
        public object vmulxd_laneq_f64(object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar);
        
        /// <summary>
        /// float32x4_t vmulxq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FMULX Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vmulxq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulxq_f32", Category)]
        public object vmulxq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtended);
        
        /// <summary>
        /// float64x2_t vmulxq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMULX Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vmulxq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulxq_f64", Category)]
        public object vmulxq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtended);
        
        /// <summary>
        /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane)
        ///A64: FMULX Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulxq_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_lane_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulxq_lane_f32", Category)]
        public object vmulxq_lane_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vmulxq_lane_f64 (float64x2_t a, float64x1_t v, const int lane)
        ///A64: FMULX Vd.2D, Vn.2D, Vm.D[0]
        ///
        ///
        ///Instruction Documentation: [vmulxq_lane_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_lane_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulxq_lane_f64", Category)]
        public object vmulxq_lane_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedByScalar);
        
        /// <summary>
        /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane)
        ///A64: FMULX Vd.4S, Vn.4S, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulxq_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_laneq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulxq_laneq_f32", Category)]
        public object vmulxq_laneq_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedBySelectedScalar);
        
        /// <summary>
        /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane)
        ///A64: FMULX Vd.2D, Vn.2D, Vm.D[lane]
        ///
        ///
        ///Instruction Documentation: [vmulxq_laneq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxq_laneq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulxq_laneq_f64", Category)]
        public object vmulxq_laneq_f64(object left, object right, byte rightIndex) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedBySelectedScalar);
        
        /// <summary>
        /// float32_t vmulxs_f32 (float32_t a, float32_t b)
        ///A64: FMULX Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vmulxs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxs_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmulxs_f32", Category)]
        public object vmulxs_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedScalar);
        
        /// <summary>
        /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane)
        ///A64: FMULX Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulxs_lane_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxs_lane_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulxs_lane_f32", Category)]
        public object vmulxs_lane_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar);
        
        /// <summary>
        /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane)
        ///A64: FMULX Sd, Sn, Vm.S[lane]
        ///
        ///
        ///Instruction Documentation: [vmulxs_laneq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulxs_laneq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="rightIndex"></param>
        /// </summary>
        [KalkExport("vmulxs_laneq_f32", Category)]
        public object vmulxs_laneq_f32(object left, object right, byte rightIndex) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, rightIndex, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MultiplyExtendedScalarBySelectedScalar);
        
        /// <summary>
        /// int64x1_t vneg_s64 (int64x1_t a)
        ///A64: NEG Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vneg_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vneg_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vneg_s64", Category)]
        public object vneg_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.NegateScalar);
        
        /// <summary>
        /// float64x2_t vnegq_f64 (float64x2_t a)
        ///A64: FNEG Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vnegq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegq_f64", Category)]
        public object vnegq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Negate);
        
        /// <summary>
        /// int64x2_t vnegq_s64 (int64x2_t a)
        ///A64: NEG Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vnegq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vnegq_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vnegq_s64", Category)]
        public object vnegq_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Negate);
        
        /// <summary>
        /// float64_t vpaddd_f64 (float64x2_t a)
        ///A64: FADDP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpaddd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddd_f64", Category)]
        public object vpaddd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwiseScalar);
        
        /// <summary>
        /// int64_t vpaddd_s64 (int64x2_t a)
        ///A64: ADDP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpaddd_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddd_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddd_s64", Category)]
        public object vpaddd_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwiseScalar);
        
        /// <summary>
        /// uint64_t vpaddd_u64 (uint64x2_t a)
        ///A64: ADDP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpaddd_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddd_u64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpaddd_u64", Category)]
        public object vpaddd_u64(object value) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwiseScalar);
        
        /// <summary>
        /// float32x4_t vpaddq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FADDP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpaddq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_f32", Category)]
        public object vpaddq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// float64x2_t vpaddq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FADDP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpaddq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_f64", Category)]
        public object vpaddq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// int16x8_t vpaddq_s16 (int16x8_t a, int16x8_t b)
        ///A64: ADDP Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vpaddq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_s16", Category)]
        public object vpaddq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// int32x4_t vpaddq_s32 (int32x4_t a, int32x4_t b)
        ///A64: ADDP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpaddq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_s32", Category)]
        public object vpaddq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// int64x2_t vpaddq_s64 (int64x2_t a, int64x2_t b)
        ///A64: ADDP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpaddq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_s64", Category)]
        public object vpaddq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// int8x16_t vpaddq_s8 (int8x16_t a, int8x16_t b)
        ///A64: ADDP Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vpaddq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_s8", Category)]
        public object vpaddq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// uint16x8_t vpaddq_u16 (uint16x8_t a, uint16x8_t b)
        ///A64: ADDP Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vpaddq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_u16", Category)]
        public object vpaddq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// uint32x4_t vpaddq_u32 (uint32x4_t a, uint32x4_t b)
        ///A64: ADDP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpaddq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_u32", Category)]
        public object vpaddq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// uint64x2_t vpaddq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: ADDP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpaddq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_u64", Category)]
        public object vpaddq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// uint8x16_t vpaddq_u8 (uint8x16_t a, uint8x16_t b)
        ///A64: ADDP Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vpaddq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpaddq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpaddq_u8", Category)]
        public object vpaddq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwise);
        
        /// <summary>
        /// float32_t vpadds_f32 (float32x2_t a)
        ///A64: FADDP Sd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpadds_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpadds_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpadds_f32", Category)]
        public object vpadds_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddPairwiseScalar);
        
        /// <summary>
        /// float32x2_t vpmaxnm_f32 (float32x2_t a, float32x2_t b)
        ///A64: FMAXNMP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpmaxnm_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnm_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxnm_f32", Category)]
        public object vpmaxnm_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumberPairwise);
        
        /// <summary>
        /// float32x4_t vpmaxnmq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FMAXNMP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpmaxnmq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxnmq_f32", Category)]
        public object vpmaxnmq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumberPairwise);
        
        /// <summary>
        /// float64x2_t vpmaxnmq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMAXNMP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpmaxnmq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxnmq_f64", Category)]
        public object vpmaxnmq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumberPairwise);
        
        /// <summary>
        /// float64_t vpmaxnmqd_f64 (float64x2_t a)
        ///A64: FMAXNMP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpmaxnmqd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnmqd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpmaxnmqd_f64", Category)]
        public object vpmaxnmqd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumberPairwiseScalar);
        
        /// <summary>
        /// float32_t vpmaxnms_f32 (float32x2_t a)
        ///A64: FMAXNMP Sd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpmaxnms_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxnms_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpmaxnms_f32", Category)]
        public object vpmaxnms_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxNumberPairwiseScalar);
        
        /// <summary>
        /// float32x4_t vpmaxq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FMAXP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpmaxq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_f32", Category)]
        public object vpmaxq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// float64x2_t vpmaxq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMAXP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpmaxq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_f64", Category)]
        public object vpmaxq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// int16x8_t vpmaxq_s16 (int16x8_t a, int16x8_t b)
        ///A64: SMAXP Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vpmaxq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_s16", Category)]
        public object vpmaxq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// int32x4_t vpmaxq_s32 (int32x4_t a, int32x4_t b)
        ///A64: SMAXP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpmaxq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_s32", Category)]
        public object vpmaxq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// int8x16_t vpmaxq_s8 (int8x16_t a, int8x16_t b)
        ///A64: SMAXP Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vpmaxq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_s8", Category)]
        public object vpmaxq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// uint16x8_t vpmaxq_u16 (uint16x8_t a, uint16x8_t b)
        ///A64: UMAXP Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vpmaxq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_u16", Category)]
        public object vpmaxq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// uint32x4_t vpmaxq_u32 (uint32x4_t a, uint32x4_t b)
        ///A64: UMAXP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpmaxq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_u32", Category)]
        public object vpmaxq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// uint8x16_t vpmaxq_u8 (uint8x16_t a, uint8x16_t b)
        ///A64: UMAXP Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vpmaxq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpmaxq_u8", Category)]
        public object vpmaxq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwise);
        
        /// <summary>
        /// float64_t vpmaxqd_f64 (float64x2_t a)
        ///A64: FMAXP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpmaxqd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxqd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpmaxqd_f64", Category)]
        public object vpmaxqd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwiseScalar);
        
        /// <summary>
        /// float32_t vpmaxs_f32 (float32x2_t a)
        ///A64: FMAXP Sd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpmaxs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxs_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpmaxs_f32", Category)]
        public object vpmaxs_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MaxPairwiseScalar);
        
        /// <summary>
        /// float32x2_t vpminnm_f32 (float32x2_t a, float32x2_t b)
        ///A64: FMINNMP Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vpminnm_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnm_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminnm_f32", Category)]
        public object vpminnm_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumberPairwise);
        
        /// <summary>
        /// float32x4_t vpminnmq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FMINNMP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpminnmq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminnmq_f32", Category)]
        public object vpminnmq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumberPairwise);
        
        /// <summary>
        /// float64x2_t vpminnmq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMINNMP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpminnmq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminnmq_f64", Category)]
        public object vpminnmq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumberPairwise);
        
        /// <summary>
        /// float64_t vpminnmqd_f64 (float64x2_t a)
        ///A64: FMINNMP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpminnmqd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnmqd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpminnmqd_f64", Category)]
        public object vpminnmqd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumberPairwiseScalar);
        
        /// <summary>
        /// float32_t vpminnms_f32 (float32x2_t a)
        ///A64: FMINNMP Sd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpminnms_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminnms_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpminnms_f32", Category)]
        public object vpminnms_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinNumberPairwiseScalar);
        
        /// <summary>
        /// float32x4_t vpminq_f32 (float32x4_t a, float32x4_t b)
        ///A64: FMINP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpminq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_f32", Category)]
        public object vpminq_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// float64x2_t vpminq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FMINP Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vpminq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_f64", Category)]
        public object vpminq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// int16x8_t vpminq_s16 (int16x8_t a, int16x8_t b)
        ///A64: SMINP Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vpminq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_s16", Category)]
        public object vpminq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// int32x4_t vpminq_s32 (int32x4_t a, int32x4_t b)
        ///A64: SMINP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpminq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_s32", Category)]
        public object vpminq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// int8x16_t vpminq_s8 (int8x16_t a, int8x16_t b)
        ///A64: SMINP Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vpminq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_s8", Category)]
        public object vpminq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// uint16x8_t vpminq_u16 (uint16x8_t a, uint16x8_t b)
        ///A64: UMINP Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vpminq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_u16", Category)]
        public object vpminq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// uint32x4_t vpminq_u32 (uint32x4_t a, uint32x4_t b)
        ///A64: UMINP Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vpminq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_u32", Category)]
        public object vpminq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// uint8x16_t vpminq_u8 (uint8x16_t a, uint8x16_t b)
        ///A64: UMINP Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vpminq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vpminq_u8", Category)]
        public object vpminq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwise);
        
        /// <summary>
        /// float64_t vpminqd_f64 (float64x2_t a)
        ///A64: FMINP Dd, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vpminqd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpminqd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpminqd_f64", Category)]
        public object vpminqd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwiseScalar);
        
        /// <summary>
        /// float32_t vpmins_f32 (float32x2_t a)
        ///A64: FMINP Sd, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vpmins_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmins_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vpmins_f32", Category)]
        public object vpmins_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.MinPairwiseScalar);
        
        /// <summary>
        /// int8_t vqabsb_s8 (int8_t a)
        ///A64: SQABS Bd, Bn
        ///
        ///
        ///Instruction Documentation: [vqabsb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsb_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsb_s8", Category)]
        public object vqabsb_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsSaturateScalar);
        
        /// <summary>
        /// int64_t vqabsd_s64 (int64_t a)
        ///A64: SQABS Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vqabsd_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsd_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsd_s64", Category)]
        public object vqabsd_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsSaturateScalar);
        
        /// <summary>
        /// int16_t vqabsh_s16 (int16_t a)
        ///A64: SQABS Hd, Hn
        ///
        ///
        ///Instruction Documentation: [vqabsh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsh_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsh_s16", Category)]
        public object vqabsh_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsSaturateScalar);
        
        /// <summary>
        /// int64x2_t vqabsq_s64 (int64x2_t a)
        ///A64: SQABS Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vqabsq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabsq_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabsq_s64", Category)]
        public object vqabsq_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsSaturate);
        
        /// <summary>
        /// int32_t vqabss_s32 (int32_t a)
        ///A64: SQABS Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vqabss_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqabss_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqabss_s32", Category)]
        public object vqabss_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AbsSaturateScalar);
        
        /// <summary>
        /// int8_t vqaddb_s8 (int8_t a, int8_t b)
        ///A64: SQADD Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqaddb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddb_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddb_s8", Category)]
        public object vqaddb_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// uint8_t vqaddb_u8 (uint8_t a, uint8_t b)
        ///A64: UQADD Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqaddb_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddb_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddb_u8", Category)]
        public object vqaddb_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// int16_t vqaddh_s16 (int16_t a, int16_t b)
        ///A64: SQADD Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqaddh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddh_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddh_s16", Category)]
        public object vqaddh_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// uint16_t vqaddh_u16 (uint16_t a, uint16_t b)
        ///A64: UQADD Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqaddh_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqaddh_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqaddh_u16", Category)]
        public object vqaddh_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// int32_t vqadds_s32 (int32_t a, int32_t b)
        ///A64: SQADD Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqadds_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadds_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadds_s32", Category)]
        public object vqadds_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// uint32_t vqadds_u32 (uint32_t a, uint32_t b)
        ///A64: UQADD Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqadds_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqadds_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqadds_u32", Category)]
        public object vqadds_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// int8_t vqnegb_s8 (int8_t a)
        ///A64: SQNEG Bd, Bn
        ///
        ///
        ///Instruction Documentation: [vqnegb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegb_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegb_s8", Category)]
        public object vqnegb_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.NegateSaturateScalar);
        
        /// <summary>
        /// int64_t vqnegd_s64 (int64_t a)
        ///A64: SQNEG Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vqnegd_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegd_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegd_s64", Category)]
        public object vqnegd_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.NegateSaturateScalar);
        
        /// <summary>
        /// int16_t vqnegh_s16 (int16_t a)
        ///A64: SQNEG Hd, Hn
        ///
        ///
        ///Instruction Documentation: [vqnegh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegh_s16)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegh_s16", Category)]
        public object vqnegh_s16(object value) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.NegateSaturateScalar);
        
        /// <summary>
        /// int64x2_t vqnegq_s64 (int64x2_t a)
        ///A64: SQNEG Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vqnegq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegq_s64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegq_s64", Category)]
        public object vqnegq_s64(object value) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.NegateSaturate);
        
        /// <summary>
        /// int32_t vqnegs_s32 (int32_t a)
        ///A64: SQNEG Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vqnegs_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqnegs_s32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vqnegs_s32", Category)]
        public object vqnegs_s32(object value) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.NegateSaturateScalar);
        
        /// <summary>
        /// int8_t vqrshlb_s8 (int8_t a, int8_t b)
        ///A64: SQRSHL Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqrshlb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlb_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlb_s8", Category)]
        public object vqrshlb_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftArithmeticRoundedSaturateScalar);
        
        /// <summary>
        /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b)
        ///A64: UQRSHL Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqrshlb_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlb_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlb_u8", Category)]
        public object vqrshlb_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLogicalRoundedSaturateScalar);
        
        /// <summary>
        /// int16_t vqrshlh_s16 (int16_t a, int16_t b)
        ///A64: SQRSHL Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqrshlh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlh_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlh_s16", Category)]
        public object vqrshlh_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftArithmeticRoundedSaturateScalar);
        
        /// <summary>
        /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b)
        ///A64: UQRSHL Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqrshlh_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshlh_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshlh_u16", Category)]
        public object vqrshlh_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLogicalRoundedSaturateScalar);
        
        /// <summary>
        /// int32_t vqrshls_s32 (int32_t a, int32_t b)
        ///A64: SQRSHL Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqrshls_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshls_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshls_s32", Category)]
        public object vqrshls_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftArithmeticRoundedSaturateScalar);
        
        /// <summary>
        /// uint32_t vqrshls_u32 (uint32_t a, int32_t b)
        ///A64: UQRSHL Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqrshls_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshls_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshls_u32", Category)]
        public object vqrshls_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLogicalRoundedSaturateScalar);
        
        /// <summary>
        /// int32_t vqrshrnd_n_s64 (int64_t a, const int n)
        ///A64: SQRSHRN Sd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrnd_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnd_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrnd_n_s64", Category)]
        public object vqrshrnd_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateScalar);
        
        /// <summary>
        /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n)
        ///A64: UQRSHRN Sd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrnd_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnd_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrnd_n_u64", Category)]
        public object vqrshrnd_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar);
        
        /// <summary>
        /// int8_t vqrshrnh_n_s16 (int16_t a, const int n)
        ///A64: SQRSHRN Bd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrnh_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnh_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrnh_n_s16", Category)]
        public object vqrshrnh_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateScalar);
        
        /// <summary>
        /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n)
        ///A64: UQRSHRN Bd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrnh_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrnh_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrnh_n_u16", Category)]
        public object vqrshrnh_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar);
        
        /// <summary>
        /// int16_t vqrshrns_n_s32 (int32_t a, const int n)
        ///A64: SQRSHRN Hd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrns_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrns_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrns_n_s32", Category)]
        public object vqrshrns_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateScalar);
        
        /// <summary>
        /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
        ///A64: UQRSHRN Hd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrns_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrns_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrns_n_u32", Category)]
        public object vqrshrns_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar);
        
        /// <summary>
        /// uint32_t vqrshrund_n_s64 (int64_t a, const int n)
        ///A64: SQRSHRUN Sd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrund_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrund_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrund_n_s64", Category)]
        public object vqrshrund_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar);
        
        /// <summary>
        /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n)
        ///A64: SQRSHRUN Bd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshrunh_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshrunh_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshrunh_n_s16", Category)]
        public object vqrshrunh_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar);
        
        /// <summary>
        /// uint16_t vqrshruns_n_s32 (int32_t a, const int n)
        ///A64: SQRSHRUN Hd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqrshruns_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqrshruns_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqrshruns_n_s32", Category)]
        public object vqrshruns_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar);
        
        /// <summary>
        /// int8_t vqshlb_n_s8 (int8_t a, const int n)
        ///A64: SQSHL Bd, Bn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlb_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlb_n_s8", Category)]
        public object vqshlb_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// uint8_t vqshlb_n_u8 (uint8_t a, const int n)
        ///A64: UQSHL Bd, Bn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlb_n_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_n_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlb_n_u8", Category)]
        public object vqshlb_n_u8(object value, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// int8_t vqshlb_s8 (int8_t a, int8_t b)
        ///A64: SQSHL Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqshlb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlb_s8", Category)]
        public object vqshlb_s8(object value, object count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftArithmeticSaturateScalar);
        
        /// <summary>
        /// uint8_t vqshlb_u8 (uint8_t a, int8_t b)
        ///A64: UQSHL Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqshlb_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlb_u8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlb_u8", Category)]
        public object vqshlb_u8(object value, object count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLogicalSaturateScalar);
        
        /// <summary>
        /// int16_t vqshlh_n_s16 (int16_t a, const int n)
        ///A64: SQSHL Hd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlh_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlh_n_s16", Category)]
        public object vqshlh_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// uint16_t vqshlh_n_u16 (uint16_t a, const int n)
        ///A64: UQSHL Hd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlh_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlh_n_u16", Category)]
        public object vqshlh_n_u16(object value, byte count) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// int16_t vqshlh_s16 (int16_t a, int16_t b)
        ///A64: SQSHL Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqshlh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlh_s16", Category)]
        public object vqshlh_s16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftArithmeticSaturateScalar);
        
        /// <summary>
        /// uint16_t vqshlh_u16 (uint16_t a, int16_t b)
        ///A64: UQSHL Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqshlh_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlh_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlh_u16", Category)]
        public object vqshlh_u16(object value, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLogicalSaturateScalar);
        
        /// <summary>
        /// int32_t vqshls_n_s32 (int32_t a, const int n)
        ///A64: SQSHL Sd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqshls_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshls_n_s32", Category)]
        public object vqshls_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// uint32_t vqshls_n_u32 (uint32_t a, const int n)
        ///A64: UQSHL Sd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqshls_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshls_n_u32", Category)]
        public object vqshls_n_u32(object value, byte count) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar);
        
        /// <summary>
        /// int32_t vqshls_s32 (int32_t a, int32_t b)
        ///A64: SQSHL Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqshls_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshls_s32", Category)]
        public object vqshls_s32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftArithmeticSaturateScalar);
        
        /// <summary>
        /// uint32_t vqshls_u32 (uint32_t a, int32_t b)
        ///A64: UQSHL Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqshls_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshls_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshls_u32", Category)]
        public object vqshls_u32(object value, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLogicalSaturateScalar);
        
        /// <summary>
        /// uint8_t vqshlub_n_s8 (int8_t a, const int n)
        ///A64: SQSHLU Bd, Bn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlub_n_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlub_n_s8)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlub_n_s8", Category)]
        public object vqshlub_n_s8(object value, byte count) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateUnsignedScalar);
        
        /// <summary>
        /// uint16_t vqshluh_n_s16 (int16_t a, const int n)
        ///A64: SQSHLU Hd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqshluh_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshluh_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshluh_n_s16", Category)]
        public object vqshluh_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateUnsignedScalar);
        
        /// <summary>
        /// uint32_t vqshlus_n_s32 (int32_t a, const int n)
        ///A64: SQSHLU Sd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqshlus_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshlus_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshlus_n_s32", Category)]
        public object vqshlus_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateUnsignedScalar);
        
        /// <summary>
        /// int32_t vqshrnd_n_s64 (int64_t a, const int n)
        ///A64: SQSHRN Sd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrnd_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnd_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrnd_n_s64", Category)]
        public object vqshrnd_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateScalar);
        
        /// <summary>
        /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n)
        ///A64: UQSHRN Sd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrnd_n_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnd_n_u64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrnd_n_u64", Category)]
        public object vqshrnd_n_u64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, int, System.Runtime.Intrinsics.Vector64<int>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar);
        
        /// <summary>
        /// int8_t vqshrnh_n_s16 (int16_t a, const int n)
        ///A64: SQSHRN Bd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrnh_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnh_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrnh_n_s16", Category)]
        public object vqshrnh_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateScalar);
        
        /// <summary>
        /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n)
        ///A64: UQSHRN Bd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrnh_n_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrnh_n_u16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrnh_n_u16", Category)]
        public object vqshrnh_n_u16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar);
        
        /// <summary>
        /// int16_t vqshrns_n_s32 (int32_t a, const int n)
        ///A64: SQSHRN Hd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrns_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrns_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrns_n_s32", Category)]
        public object vqshrns_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateScalar);
        
        /// <summary>
        /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
        ///A64: UQSHRN Hd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrns_n_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrns_n_u32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrns_n_u32", Category)]
        public object vqshrns_n_u32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, short, System.Runtime.Intrinsics.Vector64<short>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar);
        
        /// <summary>
        /// uint32_t vqshrund_n_s64 (int64_t a, const int n)
        ///A64: SQSHRUN Sd, Dn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrund_n_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrund_n_s64)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrund_n_s64", Category)]
        public object vqshrund_n_s64(object value, byte count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, byte, byte, uint, System.Runtime.Intrinsics.Vector64<uint>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateUnsignedScalar);
        
        /// <summary>
        /// uint8_t vqshrunh_n_s16 (int16_t a, const int n)
        ///A64: SQSHRUN Bd, Hn, #n
        ///
        ///
        ///Instruction Documentation: [vqshrunh_n_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshrunh_n_s16)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshrunh_n_s16", Category)]
        public object vqshrunh_n_s16(object value, byte count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, byte, byte, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateUnsignedScalar);
        
        /// <summary>
        /// uint16_t vqshruns_n_s32 (int32_t a, const int n)
        ///A64: SQSHRUN Hd, Sn, #n
        ///
        ///
        ///Instruction Documentation: [vqshruns_n_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqshruns_n_s32)
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("vqshruns_n_s32", Category)]
        public object vqshruns_n_s32(object value, byte count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, byte, byte, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(value, count, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateUnsignedScalar);
        
        /// <summary>
        /// int8_t vqsubb_s8 (int8_t a, int8_t b)
        ///A64: SQSUB Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqsubb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubb_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubb_s8", Category)]
        public object vqsubb_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.SubtractSaturateScalar);
        
        /// <summary>
        /// uint8_t vqsubb_u8 (uint8_t a, uint8_t b)
        ///A64: UQSUB Bd, Bn, Bm
        ///
        ///
        ///Instruction Documentation: [vqsubb_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubb_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubb_u8", Category)]
        public object vqsubb_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.SubtractSaturateScalar);
        
        /// <summary>
        /// int16_t vqsubh_s16 (int16_t a, int16_t b)
        ///A64: SQSUB Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqsubh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubh_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubh_s16", Category)]
        public object vqsubh_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.SubtractSaturateScalar);
        
        /// <summary>
        /// uint16_t vqsubh_u16 (uint16_t a, uint16_t b)
        ///A64: UQSUB Hd, Hn, Hm
        ///
        ///
        ///Instruction Documentation: [vqsubh_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubh_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubh_u16", Category)]
        public object vqsubh_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.SubtractSaturateScalar);
        
        /// <summary>
        /// int32_t vqsubs_s32 (int32_t a, int32_t b)
        ///A64: SQSUB Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqsubs_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubs_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubs_s32", Category)]
        public object vqsubs_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.SubtractSaturateScalar);
        
        /// <summary>
        /// uint32_t vqsubs_u32 (uint32_t a, uint32_t b)
        ///A64: UQSUB Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vqsubs_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqsubs_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vqsubs_u32", Category)]
        public object vqsubs_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.SubtractSaturateScalar);
        
        /// <summary>
        /// int8x16_t vqvtbl1q_s8(int8x16_t t, uint8x16_t idx)
        ///A64: TBL Vd.16B, {Vn.16B}, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqvtbl1q_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbl1q_s8)
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbl1q_s8", Category)]
        public object vqvtbl1q_s8(object table, object byteIndexes) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.VectorTableLookup);
        
        /// <summary>
        /// uint8x16_t vqvtbl1q_u8(uint8x16_t t, uint8x16_t idx)
        ///A64: TBL Vd.16B, {Vn.16B}, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqvtbl1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbl1q_u8)
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbl1q_u8", Category)]
        public object vqvtbl1q_u8(object table, object byteIndexes) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.VectorTableLookup);
        
        /// <summary>
        /// int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx)
        ///A64: TBX Vd.16B, {Vn.16B}, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqvtbx1q_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbx1q_s8)
        /// <param name="defaultValues"></param>
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbx1q_s8", Category)]
        public object vqvtbx1q_s8(object defaultValues, object table, object byteIndexes) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(defaultValues, table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.VectorTableLookupExtension);
        
        /// <summary>
        /// uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx)
        ///A64: TBX Vd.16B, {Vn.16B}, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vqvtbx1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vqvtbx1q_u8)
        /// <param name="defaultValues"></param>
        /// <param name="table"></param>
        /// <param name="byteIndexes"></param>
        /// </summary>
        [KalkExport("vqvtbx1q_u8", Category)]
        public object vqvtbx1q_u8(object defaultValues, object table, object byteIndexes) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(defaultValues, table, byteIndexes, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.VectorTableLookupExtension);
        
        /// <summary>
        /// int8x8_t vrbit_s8 (int8x8_t a)
        ///A64: RBIT Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vrbit_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbit_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrbit_s8", Category)]
        public object vrbit_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReverseElementBits);
        
        /// <summary>
        /// uint8x8_t vrbit_u8 (uint8x8_t a)
        ///A64: RBIT Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vrbit_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbit_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrbit_u8", Category)]
        public object vrbit_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReverseElementBits);
        
        /// <summary>
        /// int8x16_t vrbitq_s8 (int8x16_t a)
        ///A64: RBIT Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vrbitq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbitq_s8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrbitq_s8", Category)]
        public object vrbitq_s8(object value) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReverseElementBits);
        
        /// <summary>
        /// uint8x16_t vrbitq_u8 (uint8x16_t a)
        ///A64: RBIT Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vrbitq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrbitq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrbitq_u8", Category)]
        public object vrbitq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReverseElementBits);
        
        /// <summary>
        /// float64x1_t vrecpe_f64 (float64x1_t a)
        ///A64: FRECPE Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrecpe_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpe_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpe_f64", Category)]
        public object vrecpe_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalEstimateScalar);
        
        /// <summary>
        /// float64x2_t vrecpeq_f64 (float64x2_t a)
        ///A64: FRECPE Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrecpeq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpeq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpeq_f64", Category)]
        public object vrecpeq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalEstimate);
        
        /// <summary>
        /// float32_t vrecpes_f32 (float32_t a)
        ///A64: FRECPE Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vrecpes_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpes_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpes_f32", Category)]
        public object vrecpes_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalEstimateScalar);
        
        /// <summary>
        /// float64x1_t vrecps_f64 (float64x1_t a, float64x1_t b)
        ///A64: FRECPS Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vrecps_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecps_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrecps_f64", Category)]
        public object vrecps_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalStepScalar);
        
        /// <summary>
        /// float64x2_t vrecpsq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FRECPS Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrecpsq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpsq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrecpsq_f64", Category)]
        public object vrecpsq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalStep);
        
        /// <summary>
        /// float32_t vrecpss_f32 (float32_t a, float32_t b)
        ///A64: FRECPS Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vrecpss_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpss_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrecpss_f32", Category)]
        public object vrecpss_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalStepScalar);
        
        /// <summary>
        /// float64_t vrecpxd_f64 (float64_t a)
        ///A64: FRECPX Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrecpxd_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpxd_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpxd_f64", Category)]
        public object vrecpxd_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalExponentScalar);
        
        /// <summary>
        /// float32_t vrecpxs_f32 (float32_t a)
        ///A64: FRECPX Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vrecpxs_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrecpxs_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrecpxs_f32", Category)]
        public object vrecpxs_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalExponentScalar);
        
        /// <summary>
        /// float64x2_t vrndaq_f64 (float64x2_t a)
        ///A64: FRINTA Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrndaq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndaq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndaq_f64", Category)]
        public object vrndaq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.RoundAwayFromZero);
        
        /// <summary>
        /// float64x2_t vrndmq_f64 (float64x2_t a)
        ///A64: FRINTM Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrndmq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndmq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndmq_f64", Category)]
        public object vrndmq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Floor);
        
        /// <summary>
        /// float64x2_t vrndnq_f64 (float64x2_t a)
        ///A64: FRINTN Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrndnq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndnq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndnq_f64", Category)]
        public object vrndnq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.RoundToNearest);
        
        /// <summary>
        /// float64x2_t vrndpq_f64 (float64x2_t a)
        ///A64: FRINTP Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrndpq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndpq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndpq_f64", Category)]
        public object vrndpq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Ceiling);
        
        /// <summary>
        /// float64x2_t vrndq_f64 (float64x2_t a)
        ///A64: FRINTZ Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrndq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrndq_f64", Category)]
        public object vrndq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.RoundToZero);
        
        /// <summary>
        /// float64x1_t vrsqrte_f64 (float64x1_t a)
        ///A64: FRSQRTE Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vrsqrte_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrte_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrte_f64", Category)]
        public object vrsqrte_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalSquareRootEstimateScalar);
        
        /// <summary>
        /// float64x2_t vrsqrteq_f64 (float64x2_t a)
        ///A64: FRSQRTE Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vrsqrteq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrteq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrteq_f64", Category)]
        public object vrsqrteq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalSquareRootEstimate);
        
        /// <summary>
        /// float32_t vrsqrtes_f32 (float32_t a)
        ///A64: FRSQRTE Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vrsqrtes_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtes_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vrsqrtes_f32", Category)]
        public object vrsqrtes_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalSquareRootEstimateScalar);
        
        /// <summary>
        /// float64x1_t vrsqrts_f64 (float64x1_t a, float64x1_t b)
        ///A64: FRSQRTS Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vrsqrts_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrts_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsqrts_f64", Category)]
        public object vrsqrts_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalSquareRootStepScalar);
        
        /// <summary>
        /// float64x2_t vrsqrtsq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FRSQRTS Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vrsqrtsq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtsq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsqrtsq_f64", Category)]
        public object vrsqrtsq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalSquareRootStep);
        
        /// <summary>
        /// float32_t vrsqrtss_f32 (float32_t a, float32_t b)
        ///A64: FRSQRTS Sd, Sn, Sm
        ///
        ///
        ///Instruction Documentation: [vrsqrtss_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrsqrtss_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vrsqrtss_f32", Category)]
        public object vrsqrtss_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ReciprocalSquareRootStepScalar);
        
        /// <summary>
        /// uint16x4_t vsqadd_u16 (uint16x4_t a, int16x4_t b)
        ///A64: USQADD Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vsqadd_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqadd_u16", Category)]
        public object vsqadd_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, short, System.Runtime.Intrinsics.Vector64<short>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint32x2_t vsqadd_u32 (uint32x2_t a, int32x2_t b)
        ///A64: USQADD Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vsqadd_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqadd_u32", Category)]
        public object vsqadd_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, int, System.Runtime.Intrinsics.Vector64<int>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint64x1_t vsqadd_u64 (uint64x1_t a, int64x1_t b)
        ///A64: USQADD Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vsqadd_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqadd_u64", Category)]
        public object vsqadd_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, long, System.Runtime.Intrinsics.Vector64<long>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// uint8x8_t vsqadd_u8 (uint8x8_t a, int8x8_t b)
        ///A64: USQADD Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vsqadd_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadd_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqadd_u8", Category)]
        public object vsqadd_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint8_t vsqaddb_u8 (uint8_t a, int8_t b)
        ///A64: USQADD Bd, Bn
        ///
        ///
        ///Instruction Documentation: [vsqaddb_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddb_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqaddb_u8", Category)]
        public object vsqaddb_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// uint16_t vsqaddh_u16 (uint16_t a, int16_t b)
        ///A64: USQADD Hd, Hn
        ///
        ///
        ///Instruction Documentation: [vsqaddh_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddh_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqaddh_u16", Category)]
        public object vsqaddh_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, short, System.Runtime.Intrinsics.Vector64<short>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// uint16x8_t vsqaddq_u16 (uint16x8_t a, int16x8_t b)
        ///A64: USQADD Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vsqaddq_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqaddq_u16", Category)]
        public object vsqaddq_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, short, System.Runtime.Intrinsics.Vector128<short>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint32x4_t vsqaddq_u32 (uint32x4_t a, int32x4_t b)
        ///A64: USQADD Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vsqaddq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqaddq_u32", Category)]
        public object vsqaddq_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint64x2_t vsqaddq_u64 (uint64x2_t a, int64x2_t b)
        ///A64: USQADD Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vsqaddq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqaddq_u64", Category)]
        public object vsqaddq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, long, System.Runtime.Intrinsics.Vector128<long>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint8x16_t vsqaddq_u8 (uint8x16_t a, int8x16_t b)
        ///A64: USQADD Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vsqaddq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqaddq_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqaddq_u8", Category)]
        public object vsqaddq_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// uint32_t vsqadds_u32 (uint32_t a, int32_t b)
        ///A64: USQADD Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vsqadds_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqadds_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsqadds_u32", Category)]
        public object vsqadds_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, int, System.Runtime.Intrinsics.Vector64<int>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// float32x2_t vsqrt_f32 (float32x2_t a)
        ///A64: FSQRT Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vsqrt_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrt_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vsqrt_f32", Category)]
        public object vsqrt_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Sqrt);
        
        /// <summary>
        /// float32x4_t vsqrtq_f32 (float32x4_t a)
        ///A64: FSQRT Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vsqrtq_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrtq_f32)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vsqrtq_f32", Category)]
        public object vsqrtq_f32(object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Sqrt);
        
        /// <summary>
        /// float64x2_t vsqrtq_f64 (float64x2_t a)
        ///A64: FSQRT Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vsqrtq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsqrtq_f64)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vsqrtq_f64", Category)]
        public object vsqrtq_f64(object value) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(value, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Sqrt);
        
        /// <summary>
        /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b)
        ///A64: FSUB Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vsubq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsubq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vsubq_f64", Category)]
        public object vsubq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.Subtract);
        
        /// <summary>
        /// float32x2_t vtrn1_f32(float32x2_t a, float32x2_t b)
        ///A64: TRN1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtrn1_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_f32", Category)]
        public object vtrn1_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// int16x4_t vtrn1_s16(int16x4_t a, int16x4_t b)
        ///A64: TRN1 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vtrn1_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_s16", Category)]
        public object vtrn1_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// int32x2_t vtrn1_s32(int32x2_t a, int32x2_t b)
        ///A64: TRN1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtrn1_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_s32", Category)]
        public object vtrn1_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// int8x8_t vtrn1_s8(int8x8_t a, int8x8_t b)
        ///A64: TRN1 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vtrn1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_s8", Category)]
        public object vtrn1_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint16x4_t vtrn1_u16(uint16x4_t a, uint16x4_t b)
        ///A64: TRN1 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vtrn1_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_u16", Category)]
        public object vtrn1_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint32x2_t vtrn1_u32(uint32x2_t a, uint32x2_t b)
        ///A64: TRN1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtrn1_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_u32", Category)]
        public object vtrn1_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint8x8_t vtrn1_u8(uint8x8_t a, uint8x8_t b)
        ///A64: TRN1 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vtrn1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1_u8", Category)]
        public object vtrn1_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// float32x4_t vtrn1q_f32(float32x4_t a, float32x4_t b)
        ///A64: TRN1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtrn1q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_f32", Category)]
        public object vtrn1q_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// float64x2_t vtrn1q_f64(float64x2_t a, float64x2_t b)
        ///A64: TRN1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtrn1q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_f64", Category)]
        public object vtrn1q_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// int16x8_t vtrn1q_s16(int16x8_t a, int16x8_t b)
        ///A64: TRN1 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vtrn1q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_s16", Category)]
        public object vtrn1q_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// int32x4_t vtrn1q_s32(int32x4_t a, int32x4_t b)
        ///A64: TRN1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtrn1q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_s32", Category)]
        public object vtrn1q_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// int64x2_t vtrn1q_s64(int64x2_t a, int64x2_t b)
        ///A64: TRN1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtrn1q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_s64", Category)]
        public object vtrn1q_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint16x8_t vtrn1q_u16(uint16x8_t a, uint16x8_t b)
        ///A64: TRN1 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vtrn1q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_u16", Category)]
        public object vtrn1q_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint32x4_t vtrn1q_u32(uint32x4_t a, uint32x4_t b)
        ///A64: TRN1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtrn1q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_u32", Category)]
        public object vtrn1q_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint64x2_t vtrn1q_u64(uint64x2_t a, uint64x2_t b)
        ///A64: TRN1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtrn1q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_u64", Category)]
        public object vtrn1q_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// uint8x16_t vtrn1q_u8(uint8x16_t a, uint8x16_t b)
        ///A64: TRN1 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vtrn1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn1q_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn1q_u8", Category)]
        public object vtrn1q_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeEven);
        
        /// <summary>
        /// float32x2_t vtrn2_f32(float32x2_t a, float32x2_t b)
        ///A64: TRN2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtrn2_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_f32", Category)]
        public object vtrn2_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// int16x4_t vtrn2_s16(int16x4_t a, int16x4_t b)
        ///A64: TRN2 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vtrn2_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_s16", Category)]
        public object vtrn2_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// int32x2_t vtrn2_s32(int32x2_t a, int32x2_t b)
        ///A64: TRN2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtrn2_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_s32", Category)]
        public object vtrn2_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// int8x8_t vtrn2_s8(int8x8_t a, int8x8_t b)
        ///A64: TRN2 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vtrn2_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_s8", Category)]
        public object vtrn2_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// uint16x4_t vtrn2_u16(uint16x4_t a, uint16x4_t b)
        ///A64: TRN2 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vtrn2_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_u16", Category)]
        public object vtrn2_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// uint32x2_t vtrn2_u32(uint32x2_t a, uint32x2_t b)
        ///A64: TRN2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vtrn2_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_u32", Category)]
        public object vtrn2_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// uint8x8_t vtrn2_u8(uint8x8_t a, uint8x8_t b)
        ///A64: TRN2 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vtrn2_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2_u8", Category)]
        public object vtrn2_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// float32x4_t vtrn2q_f32(float32x4_t a, float32x4_t b)
        ///A64: TRN2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtrn2q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_f32", Category)]
        public object vtrn2q_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// float64x2_t vtrn2q_f64(float64x2_t a, float64x2_t b)
        ///A64: TRN2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtrn2q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_f64", Category)]
        public object vtrn2q_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// int16x8_t vtrn2q_s16(int16x8_t a, int16x8_t b)
        ///A64: TRN2 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vtrn2q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_s16", Category)]
        public object vtrn2q_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// int32x4_t vtrn2q_s32(int32x4_t a, int32x4_t b)
        ///A64: TRN2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vtrn2q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_s32", Category)]
        public object vtrn2q_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// int64x2_t vtrn2q_s64(int64x2_t a, int64x2_t b)
        ///A64: TRN2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtrn2q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_s64", Category)]
        public object vtrn2q_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// uint16x8_t vtrn2q_u16(uint16x8_t a, uint16x8_t b)
        ///A64: TRN2 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vtrn2q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_u16", Category)]
        public object vtrn2q_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// uint8x16_t vtrn2q_u8(uint8x16_t a, uint8x16_t b)
        ///A64: TRN2 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vtrn2q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtrn2q_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtrn2q_u8", Category)]
        public object vtrn2q_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.TransposeOdd);
        
        /// <summary>
        /// uint64x1_t vtst_f64 (float64x1_t a, float64x1_t b)
        ///A64: CMTST Dd, Dn, Dm The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vtst_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_f64", Category)]
        public object vtst_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>, double, System.Runtime.Intrinsics.Vector64<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareTestScalar);
        
        /// <summary>
        /// uint64x1_t vtst_s64 (int64x1_t a, int64x1_t b)
        ///A64: CMTST Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vtst_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_s64", Category)]
        public object vtst_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareTestScalar);
        
        /// <summary>
        /// uint64x1_t vtst_u64 (uint64x1_t a, uint64x1_t b)
        ///A64: CMTST Dd, Dn, Dm
        ///
        ///
        ///Instruction Documentation: [vtst_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtst_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtst_u64", Category)]
        public object vtst_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, ulong, System.Runtime.Intrinsics.Vector64<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareTestScalar);
        
        /// <summary>
        /// uint64x2_t vtstq_f64 (float64x2_t a, float64x2_t b)
        ///A64: CMTST Vd.2D, Vn.2D, Vm.2D The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
        ///
        ///
        ///Instruction Documentation: [vtstq_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_f64", Category)]
        public object vtstq_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareTest);
        
        /// <summary>
        /// uint64x2_t vtstq_s64 (int64x2_t a, int64x2_t b)
        ///A64: CMTST Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtstq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_s64", Category)]
        public object vtstq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareTest);
        
        /// <summary>
        /// uint64x2_t vtstq_u64 (uint64x2_t a, uint64x2_t b)
        ///A64: CMTST Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vtstq_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vtstq_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vtstq_u64", Category)]
        public object vtstq_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.CompareTest);
        
        /// <summary>
        /// int16x4_t vuqadd_s16 (int16x4_t a, uint16x4_t b)
        ///A64: SUQADD Vd.4H, Vn.4H
        ///
        ///
        ///Instruction Documentation: [vuqadd_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqadd_s16", Category)]
        public object vuqadd_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int32x2_t vuqadd_s32 (int32x2_t a, uint32x2_t b)
        ///A64: SUQADD Vd.2S, Vn.2S
        ///
        ///
        ///Instruction Documentation: [vuqadd_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqadd_s32", Category)]
        public object vuqadd_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, uint, System.Runtime.Intrinsics.Vector64<uint>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int64x1_t vuqadd_s64 (int64x1_t a, uint64x1_t b)
        ///A64: SUQADD Dd, Dn
        ///
        ///
        ///Instruction Documentation: [vuqadd_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqadd_s64", Category)]
        public object vuqadd_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, ulong, System.Runtime.Intrinsics.Vector64<ulong>, long, System.Runtime.Intrinsics.Vector64<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// int8x8_t vuqadd_s8 (int8x8_t a, uint8x8_t b)
        ///A64: SUQADD Vd.8B, Vn.8B
        ///
        ///
        ///Instruction Documentation: [vuqadd_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadd_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqadd_s8", Category)]
        public object vuqadd_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int8_t vuqaddb_s8 (int8_t a, uint8_t b)
        ///A64: SUQADD Bd, Bn
        ///
        ///
        ///Instruction Documentation: [vuqaddb_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddb_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqaddb_s8", Category)]
        public object vuqaddb_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, byte, System.Runtime.Intrinsics.Vector64<byte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// int16_t vuqaddh_s16 (int16_t a, uint16_t b)
        ///A64: SUQADD Hd, Hn
        ///
        ///
        ///Instruction Documentation: [vuqaddh_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddh_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqaddh_s16", Category)]
        public object vuqaddh_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// int16x8_t vuqaddq_s16 (int16x8_t a, uint16x8_t b)
        ///A64: SUQADD Vd.8H, Vn.8H
        ///
        ///
        ///Instruction Documentation: [vuqaddq_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqaddq_s16", Category)]
        public object vuqaddq_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int32x4_t vuqaddq_s32 (int32x4_t a, uint32x4_t b)
        ///A64: SUQADD Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vuqaddq_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqaddq_s32", Category)]
        public object vuqaddq_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int64x2_t vuqaddq_s64 (int64x2_t a, uint64x2_t b)
        ///A64: SUQADD Vd.2D, Vn.2D
        ///
        ///
        ///Instruction Documentation: [vuqaddq_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqaddq_s64", Category)]
        public object vuqaddq_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int8x16_t vuqaddq_s8 (int8x16_t a, uint8x16_t b)
        ///A64: SUQADD Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vuqaddq_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqaddq_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqaddq_s8", Category)]
        public object vuqaddq_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturate);
        
        /// <summary>
        /// int32_t vuqadds_s32 (int32_t a, uint32_t b)
        ///A64: SUQADD Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vuqadds_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuqadds_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuqadds_s32", Category)]
        public object vuqadds_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, uint, System.Runtime.Intrinsics.Vector64<uint>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.AddSaturateScalar);
        
        /// <summary>
        /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b)
        ///A64: UZP1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vuzp1_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_f32", Category)]
        public object vuzp1_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b)
        ///A64: UZP1 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vuzp1_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_s16", Category)]
        public object vuzp1_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b)
        ///A64: UZP1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vuzp1_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_s32", Category)]
        public object vuzp1_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b)
        ///A64: UZP1 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vuzp1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_s8", Category)]
        public object vuzp1_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b)
        ///A64: UZP1 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vuzp1_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_u16", Category)]
        public object vuzp1_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b)
        ///A64: UZP1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vuzp1_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_u32", Category)]
        public object vuzp1_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b)
        ///A64: UZP1 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vuzp1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1_u8", Category)]
        public object vuzp1_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b)
        ///A64: UZP1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vuzp1q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_f32", Category)]
        public object vuzp1q_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b)
        ///A64: UZP1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vuzp1q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_f64", Category)]
        public object vuzp1q_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b)
        ///A64: UZP1 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vuzp1q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_s16", Category)]
        public object vuzp1q_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b)
        ///A64: UZP1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vuzp1q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_s32", Category)]
        public object vuzp1q_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b)
        ///A64: UZP1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vuzp1q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_s64", Category)]
        public object vuzp1q_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b)
        ///A64: UZP1 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vuzp1q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_u16", Category)]
        public object vuzp1q_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b)
        ///A64: UZP1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vuzp1q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_u32", Category)]
        public object vuzp1q_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b)
        ///A64: UZP1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vuzp1q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_u64", Category)]
        public object vuzp1q_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b)
        ///A64: UZP1 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vuzp1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp1q_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp1q_u8", Category)]
        public object vuzp1q_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipEven);
        
        /// <summary>
        /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b)
        ///A64: UZP2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vuzp2_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_f32", Category)]
        public object vuzp2_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b)
        ///A64: UZP2 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vuzp2_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_s16", Category)]
        public object vuzp2_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b)
        ///A64: UZP2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vuzp2_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_s32", Category)]
        public object vuzp2_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b)
        ///A64: UZP2 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vuzp2_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_s8", Category)]
        public object vuzp2_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b)
        ///A64: UZP2 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vuzp2_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_u16", Category)]
        public object vuzp2_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b)
        ///A64: UZP2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vuzp2_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_u32", Category)]
        public object vuzp2_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b)
        ///A64: UZP2 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vuzp2_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2_u8", Category)]
        public object vuzp2_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b)
        ///A64: UZP2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vuzp2q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_f64", Category)]
        public object vuzp2q_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b)
        ///A64: UZP2 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vuzp2q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_s16", Category)]
        public object vuzp2q_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b)
        ///A64: UZP2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vuzp2q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_s32", Category)]
        public object vuzp2q_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b)
        ///A64: UZP2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vuzp2q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_s64", Category)]
        public object vuzp2q_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b)
        ///A64: UZP2 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vuzp2q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_u16", Category)]
        public object vuzp2q_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b)
        ///A64: UZP2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vuzp2q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_u32", Category)]
        public object vuzp2q_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b)
        ///A64: UZP2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vuzp2q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_u64", Category)]
        public object vuzp2q_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b)
        ///A64: UZP2 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vuzp2q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vuzp2q_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vuzp2q_u8", Category)]
        public object vuzp2q_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.UnzipOdd);
        
        /// <summary>
        /// float32x2_t vzip1_f32(float32x2_t a, float32x2_t b)
        ///A64: ZIP1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vzip1_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_f32", Category)]
        public object vzip1_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// int16x4_t vzip1_s16(int16x4_t a, int16x4_t b)
        ///A64: ZIP1 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vzip1_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_s16", Category)]
        public object vzip1_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// int32x2_t vzip1_s32(int32x2_t a, int32x2_t b)
        ///A64: ZIP1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vzip1_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_s32", Category)]
        public object vzip1_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// int8x8_t vzip1_s8(int8x8_t a, int8x8_t b)
        ///A64: ZIP1 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vzip1_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_s8", Category)]
        public object vzip1_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint16x4_t vzip1_u16(uint16x4_t a, uint16x4_t b)
        ///A64: ZIP1 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vzip1_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_u16", Category)]
        public object vzip1_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint32x2_t vzip1_u32(uint32x2_t a, uint32x2_t b)
        ///A64: ZIP1 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vzip1_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_u32", Category)]
        public object vzip1_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint8x8_t vzip1_u8(uint8x8_t a, uint8x8_t b)
        ///A64: ZIP1 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vzip1_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1_u8", Category)]
        public object vzip1_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// float32x4_t vzip1q_f32(float32x4_t a, float32x4_t b)
        ///A64: ZIP1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vzip1q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_f32", Category)]
        public object vzip1q_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// float64x2_t vzip1q_f64(float64x2_t a, float64x2_t b)
        ///A64: ZIP1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vzip1q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_f64", Category)]
        public object vzip1q_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// int16x8_t vzip1q_s16(int16x8_t a, int16x8_t b)
        ///A64: ZIP1 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vzip1q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_s16", Category)]
        public object vzip1q_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// int32x4_t vzip1q_s32(int32x4_t a, int32x4_t b)
        ///A64: ZIP1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vzip1q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_s32", Category)]
        public object vzip1q_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// int64x2_t vzip1q_s64(int64x2_t a, int64x2_t b)
        ///A64: ZIP1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vzip1q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_s64", Category)]
        public object vzip1q_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint16x8_t vzip1q_u16(uint16x8_t a, uint16x8_t b)
        ///A64: ZIP1 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vzip1q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_u16", Category)]
        public object vzip1q_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint32x4_t vzip1q_u32(uint32x4_t a, uint32x4_t b)
        ///A64: ZIP1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vzip1q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_u32", Category)]
        public object vzip1q_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint64x2_t vzip1q_u64(uint64x2_t a, uint64x2_t b)
        ///A64: ZIP1 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vzip1q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_u64", Category)]
        public object vzip1q_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// uint8x16_t vzip1q_u8(uint8x16_t a, uint8x16_t b)
        ///A64: ZIP1 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vzip1q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip1q_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip1q_u8", Category)]
        public object vzip1q_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipLow);
        
        /// <summary>
        /// float32x2_t vzip2_f32(float32x2_t a, float32x2_t b)
        ///A64: ZIP2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vzip2_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_f32", Category)]
        public object vzip2_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>, float, System.Runtime.Intrinsics.Vector64<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// int16x4_t vzip2_s16(int16x4_t a, int16x4_t b)
        ///A64: ZIP2 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vzip2_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_s16", Category)]
        public object vzip2_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>, short, System.Runtime.Intrinsics.Vector64<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// int32x2_t vzip2_s32(int32x2_t a, int32x2_t b)
        ///A64: ZIP2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vzip2_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_s32", Category)]
        public object vzip2_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>, int, System.Runtime.Intrinsics.Vector64<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// int8x8_t vzip2_s8(int8x8_t a, int8x8_t b)
        ///A64: ZIP2 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vzip2_s8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_s8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_s8", Category)]
        public object vzip2_s8(object left, object right) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>, sbyte, System.Runtime.Intrinsics.Vector64<sbyte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint16x4_t vzip2_u16(uint16x4_t a, uint16x4_t b)
        ///A64: ZIP2 Vd.4H, Vn.4H, Vm.4H
        ///
        ///
        ///Instruction Documentation: [vzip2_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_u16", Category)]
        public object vzip2_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>, ushort, System.Runtime.Intrinsics.Vector64<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint32x2_t vzip2_u32(uint32x2_t a, uint32x2_t b)
        ///A64: ZIP2 Vd.2S, Vn.2S, Vm.2S
        ///
        ///
        ///Instruction Documentation: [vzip2_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_u32", Category)]
        public object vzip2_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b)
        ///A64: ZIP2 Vd.8B, Vn.8B, Vm.8B
        ///
        ///
        ///Instruction Documentation: [vzip2_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2_u8", Category)]
        public object vzip2_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>, byte, System.Runtime.Intrinsics.Vector64<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// float32x4_t vzip2q_f32(float32x4_t a, float32x4_t b)
        ///A64: ZIP2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vzip2q_f32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_f32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_f32", Category)]
        public object vzip2q_f32(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// float64x2_t vzip2q_f64(float64x2_t a, float64x2_t b)
        ///A64: ZIP2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vzip2q_f64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_f64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_f64", Category)]
        public object vzip2q_f64(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// int16x8_t vzip2q_s16(int16x8_t a, int16x8_t b)
        ///A64: ZIP2 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vzip2q_s16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_s16", Category)]
        public object vzip2q_s16(object left, object right) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// int32x4_t vzip2q_s32(int32x4_t a, int32x4_t b)
        ///A64: ZIP2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vzip2q_s32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_s32", Category)]
        public object vzip2q_s32(object left, object right) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// int64x2_t vzip2q_s64(int64x2_t a, int64x2_t b)
        ///A64: ZIP2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vzip2q_s64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_s64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_s64", Category)]
        public object vzip2q_s64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint16x8_t vzip2q_u16(uint16x8_t a, uint16x8_t b)
        ///A64: ZIP2 Vd.8H, Vn.8H, Vm.8H
        ///
        ///
        ///Instruction Documentation: [vzip2q_u16](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u16)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_u16", Category)]
        public object vzip2q_u16(object left, object right) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint32x4_t vzip2q_u32(uint32x4_t a, uint32x4_t b)
        ///A64: ZIP2 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vzip2q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u32)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_u32", Category)]
        public object vzip2q_u32(object left, object right) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint64x2_t vzip2q_u64(uint64x2_t a, uint64x2_t b)
        ///A64: ZIP2 Vd.2D, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vzip2q_u64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_u64", Category)]
        public object vzip2q_u64(object left, object right) => (object)ProcessFunc<ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
        /// <summary>
        /// uint8x16_t vzip2q_u8(uint8x16_t a, uint8x16_t b)
        ///A64: ZIP2 Vd.16B, Vn.16B, Vm.16B
        ///
        ///
        ///Instruction Documentation: [vzip2q_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vzip2q_u8)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vzip2q_u8", Category)]
        public object vzip2q_u8(object left, object right) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(left, right, System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ZipHigh);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class AesIntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / AES";

        /// <summary>
        /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key)
        ///A32: AESD.8 Qd, Qm
        ///A64: AESD Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaesdq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaesdq_u8)
        /// <param name="value"></param>
        /// <param name="roundKey"></param>
        /// </summary>
        [KalkExport("vaesdq_u8", Category)]
        public object vaesdq_u8(object value, object roundKey) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, roundKey, System.Runtime.Intrinsics.Arm.Aes.Decrypt);
        
        /// <summary>
        /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key)
        ///A32: AESE.8 Qd, Qm
        ///A64: AESE Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaeseq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaeseq_u8)
        /// <param name="value"></param>
        /// <param name="roundKey"></param>
        /// </summary>
        [KalkExport("vaeseq_u8", Category)]
        public object vaeseq_u8(object value, object roundKey) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, roundKey, System.Runtime.Intrinsics.Arm.Aes.Encrypt);
        
        /// <summary>
        /// uint8x16_t vaesimcq_u8 (uint8x16_t data)
        ///A32: AESIMC.8 Qd, Qm
        ///A64: AESIMC Vd.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaesimcq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaesimcq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaesimcq_u8", Category)]
        public object vaesimcq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.Aes.InverseMixColumns);
        
        /// <summary>
        /// uint8x16_t vaesmcq_u8 (uint8x16_t data)
        ///A32: AESMC.8 Qd, Qm
        ///A64: AESMC V>.16B, Vn.16B
        ///
        ///
        ///Instruction Documentation: [vaesmcq_u8](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaesmcq_u8)
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("vaesmcq_u8", Category)]
        public object vaesmcq_u8(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.Arm.Aes.MixColumns);
        
        /// <summary>
        /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b)
        ///A32: VMULL.P8 Qd, Dn+1, Dm+1
        ///A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D
        ///
        ///
        ///Instruction Documentation: [vmull_high_p64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_p64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_high_p64", Category)]
        public object vmull_high_p64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.Aes.PolynomialMultiplyWideningUpper);
        
        /// <summary>
        /// poly128_t vmull_p64 (poly64_t a, poly64_t b)
        ///A32: VMULL.P8 Qd, Dn, Dm
        ///A64: PMULL Vd.1Q, Vn.1D, Vm.1D
        ///
        ///
        ///Instruction Documentation: [vmull_p64](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_p64)
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("vmull_p64", Category)]
        public object vmull_p64(object left, object right) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector64<long>, long, System.Runtime.Intrinsics.Vector128<long>>(left, right, System.Runtime.Intrinsics.Arm.Aes.PolynomialMultiplyWideningLower);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class Crc32IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / CRC32";

        /// <summary>
        /// uint32_t __crc32b (uint32_t a, uint8_t b)
        ///A32: CRC32B Rd, Rn, Rm
        ///A64: CRC32B Wd, Wn, Wm
        ///
        ///
        ///Instruction Documentation: [crc32b](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32b)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32b", Category)]
        public uint crc32b(uint crc, byte data) => (uint)ProcessFunc<uint, uint, byte, byte, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.ComputeCrc32);
        
        /// <summary>
        /// uint32_t __crc32cb (uint32_t a, uint8_t b)
        ///A32: CRC32CB Rd, Rn, Rm
        ///A64: CRC32CB Wd, Wn, Wm
        ///
        ///
        ///Instruction Documentation: [crc32cb](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32cb)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32cb", Category)]
        public uint crc32cb(uint crc, byte data) => (uint)ProcessFunc<uint, uint, byte, byte, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.ComputeCrc32C);
        
        /// <summary>
        /// uint32_t __crc32ch (uint32_t a, uint16_t b)
        ///A32: CRC32CH Rd, Rn, Rm
        ///A64: CRC32CH Wd, Wn, Wm
        ///
        ///
        ///Instruction Documentation: [crc32ch](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32ch)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32ch", Category)]
        public uint crc32ch(uint crc, ushort data) => (uint)ProcessFunc<uint, uint, ushort, ushort, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.ComputeCrc32C);
        
        /// <summary>
        /// uint32_t __crc32cw (uint32_t a, uint32_t b)
        ///A32: CRC32CW Rd, Rn, Rm
        ///A64: CRC32CW Wd, Wn, Wm
        ///
        ///
        ///Instruction Documentation: [crc32cw](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32cw)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32cw", Category)]
        public uint crc32cw(uint crc, uint data) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.ComputeCrc32C);
        
        /// <summary>
        /// uint32_t __crc32h (uint32_t a, uint16_t b)
        ///A32: CRC32H Rd, Rn, Rm
        ///A64: CRC32H Wd, Wn, Wm
        ///
        ///
        ///Instruction Documentation: [crc32h](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32h)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32h", Category)]
        public uint crc32h(uint crc, ushort data) => (uint)ProcessFunc<uint, uint, ushort, ushort, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.ComputeCrc32);
        
        /// <summary>
        /// uint32_t __crc32w (uint32_t a, uint32_t b)
        ///A32: CRC32W Rd, Rn, Rm
        ///A64: CRC32W Wd, Wn, Wm
        ///
        ///
        ///Instruction Documentation: [crc32w](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32w)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32w", Category)]
        public uint crc32w(uint crc, uint data) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.ComputeCrc32);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class Crc32Arm64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / CRC32";

        /// <summary>
        /// uint32_t __crc32cd (uint32_t a, uint64_t b)
        ///A64: CRC32CX Wd, Wn, Xm
        ///
        ///
        ///Instruction Documentation: [crc32cd](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32cd)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32cd", Category)]
        public uint crc32cd(uint crc, ulong data) => (uint)ProcessFunc<uint, uint, ulong, ulong, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.Arm64.ComputeCrc32C);
        
        /// <summary>
        /// uint32_t __crc32d (uint32_t a, uint64_t b)
        ///A64: CRC32X Wd, Wn, Xm
        ///
        ///
        ///Instruction Documentation: [crc32d](https://developer.arm.com/architectures/instruction-sets/intrinsics/crc32d)
        /// <param name="crc"></param>
        /// <param name="data"></param>
        /// </summary>
        [KalkExport("crc32d", Category)]
        public uint crc32d(uint crc, ulong data) => (uint)ProcessFunc<uint, uint, ulong, ulong, uint, uint>(crc, data, System.Runtime.Intrinsics.Arm.Crc32.Arm64.ComputeCrc32);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class Sha1IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / SHA1";

        /// <summary>
        /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
        ///A32: SHA1C.32 Qd, Qn, Qm
        ///A64: SHA1C Qd, Sn, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha1cq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1cq_u32)
        /// <param name="hash_abcd"></param>
        /// <param name="hash_e"></param>
        /// <param name="wk"></param>
        /// </summary>
        [KalkExport("vsha1cq_u32", Category)]
        public object vsha1cq_u32(object hash_abcd, object hash_e, object wk) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(hash_abcd, hash_e, wk, System.Runtime.Intrinsics.Arm.Sha1.HashUpdateChoose);
        
        /// <summary>
        /// uint32_t vsha1h_u32 (uint32_t hash_e)
        ///A32: SHA1H.32 Qd, Qm
        ///A64: SHA1H Sd, Sn
        ///
        ///
        ///Instruction Documentation: [vsha1h_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1h_u32)
        /// <param name="hash_e"></param>
        /// </summary>
        [KalkExport("vsha1h_u32", Category)]
        public object vsha1h_u32(object hash_e) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>>(hash_e, System.Runtime.Intrinsics.Arm.Sha1.FixedRotate);
        
        /// <summary>
        /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
        ///A32: SHA1M.32 Qd, Qn, Qm
        ///A64: SHA1M Qd, Sn, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha1mq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1mq_u32)
        /// <param name="hash_abcd"></param>
        /// <param name="hash_e"></param>
        /// <param name="wk"></param>
        /// </summary>
        [KalkExport("vsha1mq_u32", Category)]
        public object vsha1mq_u32(object hash_abcd, object hash_e, object wk) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(hash_abcd, hash_e, wk, System.Runtime.Intrinsics.Arm.Sha1.HashUpdateMajority);
        
        /// <summary>
        /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk)
        ///A32: SHA1P.32 Qd, Qn, Qm
        ///A64: SHA1P Qd, Sn, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha1pq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1pq_u32)
        /// <param name="hash_abcd"></param>
        /// <param name="hash_e"></param>
        /// <param name="wk"></param>
        /// </summary>
        [KalkExport("vsha1pq_u32", Category)]
        public object vsha1pq_u32(object hash_abcd, object hash_e, object wk) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector64<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(hash_abcd, hash_e, wk, System.Runtime.Intrinsics.Arm.Sha1.HashUpdateParity);
        
        /// <summary>
        /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11)
        ///A32: SHA1SU0.32 Qd, Qn, Qm
        ///A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha1su0q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1su0q_u32)
        /// <param name="w0_3"></param>
        /// <param name="w4_7"></param>
        /// <param name="w8_11"></param>
        /// </summary>
        [KalkExport("vsha1su0q_u32", Category)]
        public object vsha1su0q_u32(object w0_3, object w4_7, object w8_11) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(w0_3, w4_7, w8_11, System.Runtime.Intrinsics.Arm.Sha1.ScheduleUpdate0);
        
        /// <summary>
        /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15)
        ///A32: SHA1SU1.32 Qd, Qm
        ///A64: SHA1SU1 Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vsha1su1q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1su1q_u32)
        /// <param name="tw0_3"></param>
        /// <param name="w12_15"></param>
        /// </summary>
        [KalkExport("vsha1su1q_u32", Category)]
        public object vsha1su1q_u32(object tw0_3, object w12_15) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(tw0_3, w12_15, System.Runtime.Intrinsics.Arm.Sha1.ScheduleUpdate1);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.Arm
{
    public partial class Sha256IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics Arm / SHA256";

        /// <summary>
        /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk)
        ///A32: SHA256H2.32 Qd, Qn, Qm
        ///A64: SHA256H2 Qd, Qn, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha256h2q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256h2q_u32)
        /// <param name="hash_efgh"></param>
        /// <param name="hash_abcd"></param>
        /// <param name="wk"></param>
        /// </summary>
        [KalkExport("vsha256h2q_u32", Category)]
        public object vsha256h2q_u32(object hash_efgh, object hash_abcd, object wk) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(hash_efgh, hash_abcd, wk, System.Runtime.Intrinsics.Arm.Sha256.HashUpdate2);
        
        /// <summary>
        /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk)
        ///A32: SHA256H.32 Qd, Qn, Qm
        ///A64: SHA256H Qd, Qn, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha256hq_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256hq_u32)
        /// <param name="hash_abcd"></param>
        /// <param name="hash_efgh"></param>
        /// <param name="wk"></param>
        /// </summary>
        [KalkExport("vsha256hq_u32", Category)]
        public object vsha256hq_u32(object hash_abcd, object hash_efgh, object wk) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(hash_abcd, hash_efgh, wk, System.Runtime.Intrinsics.Arm.Sha256.HashUpdate1);
        
        /// <summary>
        /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7)
        ///A32: SHA256SU0.32 Qd, Qm
        ///A64: SHA256SU0 Vd.4S, Vn.4S
        ///
        ///
        ///Instruction Documentation: [vsha256su0q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256su0q_u32)
        /// <param name="w0_3"></param>
        /// <param name="w4_7"></param>
        /// </summary>
        [KalkExport("vsha256su0q_u32", Category)]
        public object vsha256su0q_u32(object w0_3, object w4_7) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(w0_3, w4_7, System.Runtime.Intrinsics.Arm.Sha256.ScheduleUpdate0);
        
        /// <summary>
        /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15)
        ///A32: SHA256SU1.32 Qd, Qn, Qm
        ///A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S
        ///
        ///
        ///Instruction Documentation: [vsha256su1q_u32](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256su1q_u32)
        /// <param name="w0_3"></param>
        /// <param name="w8_11"></param>
        /// <param name="w12_15"></param>
        /// </summary>
        [KalkExport("vsha256su1q_u32", Category)]
        public object vsha256su1q_u32(object w0_3, object w8_11, object w12_15) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(w0_3, w8_11, w12_15, System.Runtime.Intrinsics.Arm.Sha256.ScheduleUpdate1);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class AesIntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / AES";

        /// <summary>
        /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey)
        ///AESDEC xmm, xmm/m128
        /// <param name="value"></param>
        /// <param name="roundKey"></param>
        /// </summary>
        [KalkExport("mm_aesdec_si128", Category)]
        public object mm_aesdec_si128(object value, object roundKey) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, roundKey, System.Runtime.Intrinsics.X86.Aes.Decrypt);
        
        /// <summary>
        /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey)
        ///AESDECLAST xmm, xmm/m128
        /// <param name="value"></param>
        /// <param name="roundKey"></param>
        /// </summary>
        [KalkExport("mm_aesdeclast_si128", Category)]
        public object mm_aesdeclast_si128(object value, object roundKey) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, roundKey, System.Runtime.Intrinsics.X86.Aes.DecryptLast);
        
        /// <summary>
        /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey)
        ///AESENC xmm, xmm/m128
        /// <param name="value"></param>
        /// <param name="roundKey"></param>
        /// </summary>
        [KalkExport("mm_aesenc_si128", Category)]
        public object mm_aesenc_si128(object value, object roundKey) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, roundKey, System.Runtime.Intrinsics.X86.Aes.Encrypt);
        
        /// <summary>
        /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey)
        ///AESENCLAST xmm, xmm/m128
        /// <param name="value"></param>
        /// <param name="roundKey"></param>
        /// </summary>
        [KalkExport("mm_aesenclast_si128", Category)]
        public object mm_aesenclast_si128(object value, object roundKey) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, roundKey, System.Runtime.Intrinsics.X86.Aes.EncryptLast);
        
        /// <summary>
        /// __m128i _mm_aesimc_si128 (__m128i a)
        ///AESIMC xmm, xmm/m128
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("mm_aesimc_si128", Category)]
        public object mm_aesimc_si128(object value) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, System.Runtime.Intrinsics.X86.Aes.InverseMixColumns);
        
        /// <summary>
        /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
        ///AESKEYGENASSIST xmm, xmm/m128, imm8
        /// <param name="value"></param>
        /// <param name="control"></param>
        /// </summary>
        [KalkExport("mm_aeskeygenassist_si128", Category)]
        public object mm_aeskeygenassist_si128(object value, byte control) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(value, control, System.Runtime.Intrinsics.X86.Aes.KeygenAssist);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class AvxIntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / AVX";

        /// <summary>
        /// Broadcast a single-precision (32-bit) floating-point element from memory to all elements of "dst".
        ///
        ///__m128 _mm_broadcast_ss (float const * mem_addr)
        ///VBROADCASTSS xmm, m32
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_broadcast_ss", Category)]
        public object mm_broadcast_ss(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, Avx_BroadcastScalarToVector128563);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Avx_BroadcastScalarToVector128563 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0) => System.Runtime.Intrinsics.X86.Avx.BroadcastScalarToVector128((float*)arg0));
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" based on the comparison operand specified by "imm8", and store the results in "dst".
        ///
        ///__m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8)
        ///VCMPPD xmm, xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_cmp_pd", Category)]
        public object mm_cmp_pd(object a, object b, System.Runtime.Intrinsics.X86.FloatComparisonMode imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, System.Runtime.Intrinsics.X86.FloatComparisonMode, System.Runtime.Intrinsics.X86.FloatComparisonMode, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Compare);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" based on the comparison operand specified by "imm8", and store the results in "dst".
        ///
        ///__m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8)
        ///VCMPPS xmm, xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_cmp_ps", Category)]
        public object mm_cmp_ps(object a, object b, System.Runtime.Intrinsics.X86.FloatComparisonMode imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, System.Runtime.Intrinsics.X86.FloatComparisonMode, System.Runtime.Intrinsics.X86.FloatComparisonMode, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Compare);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" based on the comparison operand specified by "imm8", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8)
        ///VCMPSS xmm, xmm, xmm/m32, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_cmp_sd", Category)]
        public object mm_cmp_sd(object a, object b, System.Runtime.Intrinsics.X86.FloatComparisonMode imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, System.Runtime.Intrinsics.X86.FloatComparisonMode, System.Runtime.Intrinsics.X86.FloatComparisonMode, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.CompareScalar);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" based on the comparison operand specified by "imm8", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8)
        ///VCMPSD xmm, xmm, xmm/m64, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_cmp_ss", Category)]
        public object mm_cmp_ss(object a, object b, System.Runtime.Intrinsics.X86.FloatComparisonMode imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, System.Runtime.Intrinsics.X86.FloatComparisonMode, System.Runtime.Intrinsics.X86.FloatComparisonMode, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.CompareScalar);
        
        /// <summary>
        /// Load packed double-precision (64-bit) floating-point elements from memory into "dst" using "mask" (elements are zeroed out when the high bit of the corresponding element is not set).
        ///
        ///__m128d _mm_maskload_pd (double const * mem_addr, __m128i mask)
        ///VMASKMOVPD xmm, xmm, m128
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_maskload_pd", Category)]
        public object mm_maskload_pd(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, mask, Avx_MaskLoad668);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>, System.Runtime.Intrinsics.Vector128<double>> Avx_MaskLoad668 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.MaskLoad((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Load packed single-precision (32-bit) floating-point elements from memory into "dst" using "mask" (elements are zeroed out when the high bit of the corresponding element is not set).
        ///
        ///__m128 _mm_maskload_ps (float const * mem_addr, __m128i mask)
        ///VMASKMOVPS xmm, xmm, m128
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_maskload_ps", Category)]
        public object mm_maskload_ps(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, mask, Avx_MaskLoad670);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>, System.Runtime.Intrinsics.Vector128<float>> Avx_MaskLoad670 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.MaskLoad((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Store packed double-precision (64-bit) floating-point elements from "a" into memory using "mask".
        ///
        ///void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a)
        ///VMASKMOVPD m128, xmm, xmm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_maskstore_pd", Category)]
        public void mm_maskstore_pd(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, mask, a, Avx_MaskStore672);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>, System.Runtime.Intrinsics.Vector128<double>> Avx_MaskStore672 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx.MaskStore((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1, (System.Runtime.Intrinsics.Vector128<double>)arg2));
        /// <summary>
        /// Store packed single-precision (32-bit) floating-point elements from "a" into memory using "mask".
        ///
        ///void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a)
        ///VMASKMOVPS m128, xmm, xmm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_maskstore_ps", Category)]
        public void mm_maskstore_ps(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, mask, a, Avx_MaskStore674);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>, System.Runtime.Intrinsics.Vector128<float>> Avx_MaskStore674 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx.MaskStore((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1, (System.Runtime.Intrinsics.Vector128<float>)arg2));
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements in "a" using the control in "imm8", and store the results in "dst".
        ///
        ///__m128d _mm_permute_pd (__m128d a, int imm8)
        ///VPERMILPD xmm, xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_permute_pd", Category)]
        public object mm_permute_pd(object a, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.Permute);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" using the control in "imm8", and store the results in "dst".
        ///
        ///__m128 _mm_permute_ps (__m128 a, int imm8)
        ///VPERMILPS xmm, xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_permute_ps", Category)]
        public object mm_permute_ps(object a, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.Permute);
        
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements in "a" using the control in "b", and store the results in "dst".
        ///
        ///__m128d _mm_permutevar_pd (__m128d a, __m128i b)
        ///VPERMILPD xmm, xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_permutevar_pd", Category)]
        public object mm_permutevar_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, System.Runtime.Intrinsics.Vector128<long>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.PermuteVar);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" using the control in "b", and store the results in "dst".
        ///
        ///__m128 _mm_permutevar_ps (__m128 a, __m128i b)
        ///VPERMILPS xmm, xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_permutevar_ps", Category)]
        public object mm_permutevar_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.PermuteVar);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing double-precision (64-bit) floating-point elements) in "a" and "b", producing an intermediate 128-bit value, and set "ZF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "CF" value.
        ///
        ///int _mm_testc_pd (__m128d a, __m128d b)
        ///VTESTPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testc_pd", Category)]
        public KalkBool mm_testc_pd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestC);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing single-precision (32-bit) floating-point elements) in "a" and "b", producing an intermediate 128-bit value, and set "ZF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "CF" value.
        ///
        ///int _mm_testc_ps (__m128 a, __m128 b)
        ///VTESTPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testc_ps", Category)]
        public KalkBool mm_testc_ps(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestC);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing double-precision (64-bit) floating-point elements) in "a" and "b", producing an intermediate 128-bit value, and set "ZF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.
        ///
        ///int _mm_testnzc_pd (__m128d a, __m128d b)
        ///VTESTPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testnzc_pd", Category)]
        public KalkBool mm_testnzc_pd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestNotZAndNotC);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing single-precision (32-bit) floating-point elements) in "a" and "b", producing an intermediate 128-bit value, and set "ZF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.
        ///
        ///int _mm_testnzc_ps (__m128 a, __m128 b)
        ///VTESTPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testnzc_ps", Category)]
        public KalkBool mm_testnzc_ps(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestNotZAndNotC);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing double-precision (64-bit) floating-point elements) in "a" and "b", producing an intermediate 128-bit value, and set "ZF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "ZF" value.
        ///
        ///int _mm_testz_pd (__m128d a, __m128d b)
        ///VTESTPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testz_pd", Category)]
        public KalkBool mm_testz_pd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestZ);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing single-precision (32-bit) floating-point elements) in "a" and "b", producing an intermediate 128-bit value, and set "ZF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "ZF" value.
        ///
        ///int _mm_testz_ps (__m128 a, __m128 b)
        ///VTESTPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testz_ps", Category)]
        public KalkBool mm_testz_ps(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestZ);
        
        /// <summary>
        /// Add packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_add_pd (__m256d a, __m256d b)
        ///VADDPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_add_pd", Category)]
        public object mm256_add_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Add);
        
        /// <summary>
        /// Add packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_add_ps (__m256 a, __m256 b)
        ///VADDPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_add_ps", Category)]
        public object mm256_add_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Add);
        
        /// <summary>
        /// Alternatively add and subtract packed double-precision (64-bit) floating-point elements in "a" to/from packed elements in "b", and store the results in "dst".
        ///
        ///__m256d _mm256_addsub_pd (__m256d a, __m256d b)
        ///VADDSUBPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_addsub_pd", Category)]
        public object mm256_addsub_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.AddSubtract);
        
        /// <summary>
        /// Alternatively add and subtract packed single-precision (32-bit) floating-point elements in "a" to/from packed elements in "b", and store the results in "dst".
        ///
        ///__m256 _mm256_addsub_ps (__m256 a, __m256 b)
        ///VADDSUBPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_addsub_ps", Category)]
        public object mm256_addsub_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.AddSubtract);
        
        /// <summary>
        /// Compute the bitwise AND of packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_and_pd (__m256d a, __m256d b)
        ///VANDPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_and_pd", Category)]
        public object mm256_and_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.And);
        
        /// <summary>
        /// Compute the bitwise AND of packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_and_ps (__m256 a, __m256 b)
        ///VANDPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_and_ps", Category)]
        public object mm256_and_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.And);
        
        /// <summary>
        /// Compute the bitwise NOT of packed double-precision (64-bit) floating-point elements in "a" and then AND with "b", and store the results in "dst".
        ///
        ///__m256d _mm256_andnot_pd (__m256d a, __m256d b)
        ///VANDNPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_andnot_pd", Category)]
        public object mm256_andnot_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.AndNot);
        
        /// <summary>
        /// Compute the bitwise NOT of packed single-precision (32-bit) floating-point elements in "a" and then AND with "b", and store the results in "dst".
        ///
        ///__m256 _mm256_andnot_ps (__m256 a, __m256 b)
        ///VANDNPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_andnot_ps", Category)]
        public object mm256_andnot_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.AndNot);
        
        /// <summary>
        /// Blend packed double-precision (64-bit) floating-point elements from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8)
        ///VBLENDPD ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_blend_pd", Category)]
        public object mm256_blend_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Blend);
        
        /// <summary>
        /// Blend packed single-precision (32-bit) floating-point elements from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8)
        ///VBLENDPS ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_blend_ps", Category)]
        public object mm256_blend_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Blend);
        
        /// <summary>
        /// Blend packed double-precision (64-bit) floating-point elements from "a" and "b" using "mask", and store the results in "dst".
        ///
        ///__m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask)
        ///VBLENDVPD ymm, ymm, ymm/m256, ymm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_blendv_pd", Category)]
        public object mm256_blendv_pd(object a, object b, object mask) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, mask, System.Runtime.Intrinsics.X86.Avx.BlendVariable);
        
        /// <summary>
        /// Blend packed single-precision (32-bit) floating-point elements from "a" and "b" using "mask", and store the results in "dst".
        ///
        ///__m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask)
        ///VBLENDVPS ymm, ymm, ymm/m256, ymm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_blendv_ps", Category)]
        public object mm256_blendv_ps(object a, object b, object mask) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, mask, System.Runtime.Intrinsics.X86.Avx.BlendVariable);
        
        /// <summary>
        /// Broadcast 128 bits from memory (composed of 2 packed double-precision (64-bit) floating-point elements) to all elements of "dst".
        ///
        ///__m256d _mm256_broadcast_pd (__m128d const * mem_addr)
        ///VBROADCASTF128, ymm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_broadcast_pd", Category)]
        public object mm256_broadcast_pd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, Avx_BroadcastVector128ToVector256566);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_BroadcastVector128ToVector256566 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0) => System.Runtime.Intrinsics.X86.Avx.BroadcastVector128ToVector256((double*)arg0));
        /// <summary>
        /// Broadcast 128 bits from memory (composed of 4 packed single-precision (32-bit) floating-point elements) to all elements of "dst".
        ///
        ///__m256 _mm256_broadcast_ps (__m128 const * mem_addr)
        ///VBROADCASTF128, ymm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_broadcast_ps", Category)]
        public object mm256_broadcast_ps(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, Avx_BroadcastVector128ToVector256567);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_BroadcastVector128ToVector256567 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0) => System.Runtime.Intrinsics.X86.Avx.BroadcastVector128ToVector256((float*)arg0));
        /// <summary>
        /// Broadcast a double-precision (64-bit) floating-point element from memory to all elements of "dst".
        ///
        ///__m256d _mm256_broadcast_sd (double const * mem_addr)
        ///VBROADCASTSD ymm, m64
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_broadcast_sd", Category)]
        public object mm256_broadcast_sd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, Avx_BroadcastScalarToVector256564);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_BroadcastScalarToVector256564 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0) => System.Runtime.Intrinsics.X86.Avx.BroadcastScalarToVector256((double*)arg0));
        /// <summary>
        /// Broadcast a single-precision (32-bit) floating-point element from memory to all elements of "dst".
        ///
        ///__m256 _mm256_broadcast_ss (float const * mem_addr)
        ///VBROADCASTSS ymm, m32
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_broadcast_ss", Category)]
        public object mm256_broadcast_ss(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, Avx_BroadcastScalarToVector256565);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_BroadcastScalarToVector256565 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0) => System.Runtime.Intrinsics.X86.Avx.BroadcastScalarToVector256((float*)arg0));
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" up to an integer value, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_ceil_pd (__m256d a)
        ///VROUNDPD ymm, ymm/m256, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_ceil_pd", Category)]
        public object mm256_ceil_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.Ceiling);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" up to an integer value, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_ceil_ps (__m256 a)
        ///VROUNDPS ymm, ymm/m256, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_ceil_ps", Category)]
        public object mm256_ceil_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.Ceiling);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" based on the comparison operand specified by "imm8", and store the results in "dst".
        ///
        ///__m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
        ///VCMPPD ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_cmp_pd", Category)]
        public object mm256_cmp_pd(object a, object b, System.Runtime.Intrinsics.X86.FloatComparisonMode imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, System.Runtime.Intrinsics.X86.FloatComparisonMode, System.Runtime.Intrinsics.X86.FloatComparisonMode, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Compare);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" based on the comparison operand specified by "imm8", and store the results in "dst".
        ///
        ///__m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8)
        ///VCMPPS ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_cmp_ps", Category)]
        public object mm256_cmp_ps(object a, object b, System.Runtime.Intrinsics.X86.FloatComparisonMode imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, System.Runtime.Intrinsics.X86.FloatComparisonMode, System.Runtime.Intrinsics.X86.FloatComparisonMode, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Compare);
        
        /// <summary>
        /// __m256d _mm256_cmpeq_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(0)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpeq_pd", Category)]
        public object mm256_cmpeq_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareEqual);
        
        /// <summary>
        /// __m256 _mm256_cmpeq_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(0)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpeq_ps", Category)]
        public object mm256_cmpeq_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareEqual);
        
        /// <summary>
        /// __m256d _mm256_cmpge_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(13)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpge_pd", Category)]
        public object mm256_cmpge_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// __m256 _mm256_cmpge_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(13)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpge_ps", Category)]
        public object mm256_cmpge_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// __m256d _mm256_cmpgt_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(14)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpgt_pd", Category)]
        public object mm256_cmpgt_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareGreaterThan);
        
        /// <summary>
        /// __m256 _mm256_cmpgt_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(14)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpgt_ps", Category)]
        public object mm256_cmpgt_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareGreaterThan);
        
        /// <summary>
        /// __m256d _mm256_cmple_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(2)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmple_pd", Category)]
        public object mm256_cmple_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareLessThanOrEqual);
        
        /// <summary>
        /// __m256 _mm256_cmple_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(2)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmple_ps", Category)]
        public object mm256_cmple_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareLessThanOrEqual);
        
        /// <summary>
        /// __m256d _mm256_cmplt_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(1)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmplt_pd", Category)]
        public object mm256_cmplt_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareLessThan);
        
        /// <summary>
        /// __m256 _mm256_cmplt_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(1)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmplt_ps", Category)]
        public object mm256_cmplt_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareLessThan);
        
        /// <summary>
        /// __m256d _mm256_cmpneq_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(4)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpneq_pd", Category)]
        public object mm256_cmpneq_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotEqual);
        
        /// <summary>
        /// __m256 _mm256_cmpneq_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(4)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpneq_ps", Category)]
        public object mm256_cmpneq_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotEqual);
        
        /// <summary>
        /// __m256d _mm256_cmpnge_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(9)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpnge_pd", Category)]
        public object mm256_cmpnge_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotGreaterThanOrEqual);
        
        /// <summary>
        /// __m256 _mm256_cmpnge_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(9)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpnge_ps", Category)]
        public object mm256_cmpnge_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotGreaterThanOrEqual);
        
        /// <summary>
        /// __m256d _mm256_cmpngt_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(10)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpngt_pd", Category)]
        public object mm256_cmpngt_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotGreaterThan);
        
        /// <summary>
        /// __m256 _mm256_cmpngt_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(10)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpngt_ps", Category)]
        public object mm256_cmpngt_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotGreaterThan);
        
        /// <summary>
        /// __m256d _mm256_cmpnle_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(6)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpnle_pd", Category)]
        public object mm256_cmpnle_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotLessThanOrEqual);
        
        /// <summary>
        /// __m256 _mm256_cmpnle_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(6)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpnle_ps", Category)]
        public object mm256_cmpnle_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotLessThanOrEqual);
        
        /// <summary>
        /// __m256d _mm256_cmpnlt_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(5)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpnlt_pd", Category)]
        public object mm256_cmpnlt_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotLessThan);
        
        /// <summary>
        /// __m256 _mm256_cmpnlt_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(5)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpnlt_ps", Category)]
        public object mm256_cmpnlt_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareNotLessThan);
        
        /// <summary>
        /// __m256d _mm256_cmpord_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(7)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpord_pd", Category)]
        public object mm256_cmpord_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareOrdered);
        
        /// <summary>
        /// __m256 _mm256_cmpord_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(7)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpord_ps", Category)]
        public object mm256_cmpord_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareOrdered);
        
        /// <summary>
        /// __m256d _mm256_cmpunord_pd (__m256d a,  __m256d b) CMPPD ymm, ymm/m256, imm8(3)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpunord_pd", Category)]
        public object mm256_cmpunord_pd(object left, object right) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareUnordered);
        
        /// <summary>
        /// __m256 _mm256_cmpunord_ps (__m256 a,  __m256 b) CMPPS ymm, ymm/m256, imm8(3)
        ///The above native signature does not exist. We provide this additional overload for completeness.
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mm256_cmpunord_ps", Category)]
        public object mm256_cmpunord_ps(object left, object right) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(left, right, System.Runtime.Intrinsics.X86.Avx.CompareUnordered);
        
        /// <summary>
        /// Convert packed 32-bit integers in "a" to packed double-precision (64-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m256d _mm256_cvtepi32_pd (__m128i a)
        ///VCVTDQ2PD ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi32_pd", Category)]
        public object mm256_cvtepi32_pd(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector256Double);
        
        /// <summary>
        /// Convert packed 32-bit integers in "a" to packed single-precision (32-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m256 _mm256_cvtepi32_ps (__m256i a)
        ///VCVTDQ2PS ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi32_ps", Category)]
        public object mm256_cvtepi32_ps(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector256Single);
        
        /// <summary>
        /// Convert packed double-precision (64-bit) floating-point elements in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm256_cvtpd_epi32 (__m256d a)
        ///VCVTPD2DQ xmm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtpd_epi32", Category)]
        public object mm256_cvtpd_epi32(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector128Int32);
        
        /// <summary>
        /// Convert packed double-precision (64-bit) floating-point elements in "a" to packed single-precision (32-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m128 _mm256_cvtpd_ps (__m256d a)
        ///VCVTPD2PS xmm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtpd_ps", Category)]
        public object mm256_cvtpd_ps(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector128Single);
        
        /// <summary>
        /// Convert packed single-precision (32-bit) floating-point elements in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtps_epi32 (__m256 a)
        ///VCVTPS2DQ ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtps_epi32", Category)]
        public object mm256_cvtps_epi32(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, int, System.Runtime.Intrinsics.Vector256<int>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector256Int32);
        
        /// <summary>
        /// Convert packed single-precision (32-bit) floating-point elements in "a" to packed double-precision (64-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m256d _mm256_cvtps_pd (__m128 a)
        ///VCVTPS2PD ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtps_pd", Category)]
        public object mm256_cvtps_pd(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector256Double);
        
        /// <summary>
        /// Convert packed double-precision (64-bit) floating-point elements in "a" to packed 32-bit integers with truncation, and store the results in "dst".
        ///
        ///__m128i _mm256_cvttpd_epi32 (__m256d a)
        ///VCVTTPD2DQ xmm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvttpd_epi32", Category)]
        public object mm256_cvttpd_epi32(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector128Int32WithTruncation);
        
        /// <summary>
        /// Convert packed single-precision (32-bit) floating-point elements in "a" to packed 32-bit integers with truncation, and store the results in "dst".
        ///
        ///__m256i _mm256_cvttps_epi32 (__m256 a)
        ///VCVTTPS2DQ ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvttps_epi32", Category)]
        public object mm256_cvttps_epi32(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, int, System.Runtime.Intrinsics.Vector256<int>>(a, System.Runtime.Intrinsics.X86.Avx.ConvertToVector256Int32WithTruncation);
        
        /// <summary>
        /// Divide packed double-precision (64-bit) floating-point elements in "a" by packed elements in "b", and store the results in "dst".
        ///
        ///__m256d _mm256_div_pd (__m256d a, __m256d b)
        ///VDIVPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_div_pd", Category)]
        public object mm256_div_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Divide);
        
        /// <summary>
        /// Divide packed single-precision (32-bit) floating-point elements in "a" by packed elements in "b", and store the results in "dst".
        ///
        ///__m256 _mm256_div_ps (__m256 a, __m256 b)
        ///VDIVPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_div_ps", Category)]
        public object mm256_div_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Divide);
        
        /// <summary>
        /// Conditionally multiply the packed single-precision (32-bit) floating-point elements in "a" and "b" using the high 4 bits in "imm8", sum the four products, and conditionally store the sum in "dst" using the low 4 bits of "imm8".
        ///
        ///__m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8)
        ///VDPPS ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_dp_ps", Category)]
        public object mm256_dp_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.DotProduct);
        
        /// <summary>
        /// Extract 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from "a", selected with "imm8", and store the result in "dst".
        ///
        ///__m128d _mm256_extractf128_pd (__m256d a, const int imm8)
        ///VEXTRACTF128 xmm/m128, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_extractf128_pd", Category)]
        public object mm256_extractf128_pd(object a, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.ExtractVector128);
        
        /// <summary>
        /// Extract 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from "a", selected with "imm8", and store the result in "dst".
        ///
        ///__m128 _mm256_extractf128_ps (__m256 a, const int imm8)
        ///VEXTRACTF128 xmm/m128, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_extractf128_ps", Category)]
        public object mm256_extractf128_ps(object a, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.ExtractVector128);
        
        /// <summary>
        /// Extract 128 bits (composed of integer data) from "a", selected with "imm8", and store the result in "dst".
        ///
        ///__m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
        ///VEXTRACTF128 xmm/m128, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_extractf128_si256", Category)]
        public object mm256_extractf128_si256(object a, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.ExtractVector128);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" down to an integer value, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_floor_pd (__m256d a)
        ///VROUNDPS ymm, ymm/m256, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_floor_pd", Category)]
        public object mm256_floor_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.Floor);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" down to an integer value, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_floor_ps (__m256 a)
        ///VROUNDPS ymm, ymm/m256, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_floor_ps", Category)]
        public object mm256_floor_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.Floor);
        
        /// <summary>
        /// Horizontally add adjacent pairs of double-precision (64-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m256d _mm256_hadd_pd (__m256d a, __m256d b)
        ///VHADDPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hadd_pd", Category)]
        public object mm256_hadd_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.HorizontalAdd);
        
        /// <summary>
        /// Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m256 _mm256_hadd_ps (__m256 a, __m256 b)
        ///VHADDPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hadd_ps", Category)]
        public object mm256_hadd_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.HorizontalAdd);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of double-precision (64-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m256d _mm256_hsub_pd (__m256d a, __m256d b)
        ///VHSUBPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hsub_pd", Category)]
        public object mm256_hsub_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.HorizontalSubtract);
        
        /// <summary>
        /// Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m256 _mm256_hsub_ps (__m256 a, __m256 b)
        ///VHSUBPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hsub_ps", Category)]
        public object mm256_hsub_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.HorizontalSubtract);
        
        /// <summary>
        /// Copy "a" to "dst", then insert 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from "b" into "dst" at the location specified by "imm8".
        ///
        ///__m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
        ///VINSERTF128 ymm, ymm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_insertf128_pd", Category)]
        public object mm256_insertf128_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.InsertVector128);
        
        /// <summary>
        /// Copy "a" to "dst", then insert 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from "b" into "dst" at the location specified by "imm8".
        ///
        ///__m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
        ///VINSERTF128 ymm, ymm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_insertf128_ps", Category)]
        public object mm256_insertf128_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.InsertVector128);
        
        /// <summary>
        /// Copy "a" to "dst", then insert 128 bits from "b" into "dst" at the location specified by "imm8".
        ///
        ///__m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
        ///VINSERTF128 ymm, ymm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_insertf128_si256", Category)]
        public object mm256_insertf128_si256(object a, object b, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.InsertVector128);
        
        /// <summary>
        /// Load 256-bits of integer data from unaligned memory into "dst". This intrinsic may perform better than "_mm256_loadu_si256" when the data crosses a cache line boundary.
        ///
        ///__m256i _mm256_lddqu_si256 (__m256i const * mem_addr)
        ///VLDDQU ymm, m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_lddqu_si256", Category)]
        public object mm256_lddqu_si256(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, Avx_LoadDquVector256650);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx_LoadDquVector256650 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadDquVector256((byte*)arg0));
        /// <summary>
        /// Load 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///__m256d _mm256_load_pd (double const * mem_addr)
        ///VMOVAPD ymm, ymm/m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_load_pd", Category)]
        public object mm256_load_pd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, 32, Avx_LoadAlignedVector256641);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_LoadAlignedVector256641 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadAlignedVector256((double*)arg0));
        /// <summary>
        /// Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///__m256 _mm256_load_ps (float const * mem_addr)
        ///VMOVAPS ymm, ymm/m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_load_ps", Category)]
        public object mm256_load_ps(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, 32, Avx_LoadAlignedVector256646);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_LoadAlignedVector256646 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadAlignedVector256((float*)arg0));
        /// <summary>
        /// Load 256-bits of integer data from memory into "dst".
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///__m256i _mm256_load_si256 (__m256i const * mem_addr)
        ///VMOVDQA ymm, m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_load_si256", Category)]
        public object mm256_load_si256(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, 32, Avx_LoadAlignedVector256640);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx_LoadAlignedVector256640 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadAlignedVector256((byte*)arg0));
        /// <summary>
        /// Load 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m256d _mm256_loadu_pd (double const * mem_addr)
        ///VMOVUPD ymm, ymm/m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_loadu_pd", Category)]
        public object mm256_loadu_pd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, Avx_LoadVector256659);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_LoadVector256659 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadVector256((double*)arg0));
        /// <summary>
        /// Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m256 _mm256_loadu_ps (float const * mem_addr)
        ///VMOVUPS ymm, ymm/m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_loadu_ps", Category)]
        public object mm256_loadu_ps(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, Avx_LoadVector256664);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_LoadVector256664 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadVector256((float*)arg0));
        /// <summary>
        /// Load 256-bits of integer data from memory into "dst".
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m256i _mm256_loadu_si256 (__m256i const * mem_addr)
        ///VMOVDQU ymm, m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_loadu_si256", Category)]
        public object mm256_loadu_si256(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, Avx_LoadVector256658);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx_LoadVector256658 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx.LoadVector256((byte*)arg0));
        /// <summary>
        /// Load packed double-precision (64-bit) floating-point elements from memory into "dst" using "mask" (elements are zeroed out when the high bit of the corresponding element is not set).
        ///
        ///__m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask)
        ///VMASKMOVPD ymm, ymm, m256
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_maskload_pd", Category)]
        public object mm256_maskload_pd(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, mask, Avx_MaskLoad669);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>, System.Runtime.Intrinsics.Vector256<double>> Avx_MaskLoad669 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<double>, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.MaskLoad((double*)arg0, (System.Runtime.Intrinsics.Vector256<double>)arg1));
        /// <summary>
        /// Load packed single-precision (32-bit) floating-point elements from memory into "dst" using "mask" (elements are zeroed out when the high bit of the corresponding element is not set).
        ///
        ///__m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask)
        ///VMASKMOVPS ymm, ymm, m256
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_maskload_ps", Category)]
        public object mm256_maskload_ps(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, mask, Avx_MaskLoad671);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>, System.Runtime.Intrinsics.Vector256<float>> Avx_MaskLoad671 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<float>, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.MaskLoad((float*)arg0, (System.Runtime.Intrinsics.Vector256<float>)arg1));
        /// <summary>
        /// Store packed double-precision (64-bit) floating-point elements from "a" into memory using "mask".
        ///
        ///void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a)
        ///VMASKMOVPD m256, ymm, ymm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_maskstore_pd", Category)]
        public void mm256_maskstore_pd(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, mask, a, Avx_MaskStore673);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>, System.Runtime.Intrinsics.Vector256<double>> Avx_MaskStore673 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx.MaskStore((double*)arg0, (System.Runtime.Intrinsics.Vector256<double>)arg1, (System.Runtime.Intrinsics.Vector256<double>)arg2));
        /// <summary>
        /// Store packed single-precision (32-bit) floating-point elements from "a" into memory using "mask".
        ///
        ///void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a)
        ///VMASKMOVPS m256, ymm, ymm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_maskstore_ps", Category)]
        public void mm256_maskstore_ps(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, mask, a, Avx_MaskStore675);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>, System.Runtime.Intrinsics.Vector256<float>> Avx_MaskStore675 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx.MaskStore((float*)arg0, (System.Runtime.Intrinsics.Vector256<float>)arg1, (System.Runtime.Intrinsics.Vector256<float>)arg2));
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256d _mm256_max_pd (__m256d a, __m256d b)
        ///VMAXPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_pd", Category)]
        public object mm256_max_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Max);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256 _mm256_max_ps (__m256 a, __m256 b)
        ///VMAXPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_ps", Category)]
        public object mm256_max_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Max);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256d _mm256_min_pd (__m256d a, __m256d b)
        ///VMINPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_pd", Category)]
        public object mm256_min_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Min);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256 _mm256_min_ps (__m256 a, __m256 b)
        ///VMINPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_ps", Category)]
        public object mm256_min_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Min);
        
        /// <summary>
        /// Duplicate even-indexed double-precision (64-bit) floating-point elements from "a", and store the results in "dst".
        ///
        ///__m256d _mm256_movedup_pd (__m256d a)
        ///VMOVDDUP ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_movedup_pd", Category)]
        public object mm256_movedup_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.DuplicateEvenIndexed);
        
        /// <summary>
        /// Duplicate odd-indexed single-precision (32-bit) floating-point elements from "a", and store the results in "dst".
        ///
        ///__m256 _mm256_movehdup_ps (__m256 a)
        ///VMOVSHDUP ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_movehdup_ps", Category)]
        public object mm256_movehdup_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.DuplicateOddIndexed);
        
        /// <summary>
        /// Duplicate even-indexed single-precision (32-bit) floating-point elements from "a", and store the results in "dst".
        ///
        ///__m256 _mm256_moveldup_ps (__m256 a)
        ///VMOVSLDUP ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_moveldup_ps", Category)]
        public object mm256_moveldup_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.DuplicateEvenIndexed);
        
        /// <summary>
        /// Set each bit of mask "dst" based on the most significant bit of the corresponding packed double-precision (64-bit) floating-point element in "a".
        ///
        ///int _mm256_movemask_pd (__m256d a)
        ///VMOVMSKPD reg, ymm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_movemask_pd", Category)]
        public int mm256_movemask_pd(object a) => (int)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, int, int>(a, System.Runtime.Intrinsics.X86.Avx.MoveMask);
        
        /// <summary>
        /// Set each bit of mask "dst" based on the most significant bit of the corresponding packed single-precision (32-bit) floating-point element in "a".
        ///
        ///int _mm256_movemask_ps (__m256 a)
        ///VMOVMSKPS reg, ymm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_movemask_ps", Category)]
        public int mm256_movemask_ps(object a) => (int)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, int, int>(a, System.Runtime.Intrinsics.X86.Avx.MoveMask);
        
        /// <summary>
        /// Multiply packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_mul_pd (__m256d a, __m256d b)
        ///VMULPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mul_pd", Category)]
        public object mm256_mul_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Multiply);
        
        /// <summary>
        /// Multiply packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_mul_ps (__m256 a, __m256 b)
        ///VMULPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mul_ps", Category)]
        public object mm256_mul_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Multiply);
        
        /// <summary>
        /// Compute the bitwise OR of packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_or_pd (__m256d a, __m256d b)
        ///VORPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_or_pd", Category)]
        public object mm256_or_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Or);
        
        /// <summary>
        /// Compute the bitwise OR of packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_or_ps (__m256 a, __m256 b)
        ///VORPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_or_ps", Category)]
        public object mm256_or_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Or);
        
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements in "a" within 128-bit lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256d _mm256_permute_pd (__m256d a, int imm8)
        ///VPERMILPD ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute_pd", Category)]
        public object mm256_permute_pd(object a, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.Permute);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" within 128-bit lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256 _mm256_permute_ps (__m256 a, int imm8)
        ///VPERMILPS ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute_ps", Category)]
        public object mm256_permute_ps(object a, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(a, imm8, System.Runtime.Intrinsics.X86.Avx.Permute);
        
        /// <summary>
        /// Shuffle 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) selected by "imm8" from "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
        ///VPERM2F128 ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute2f128_pd", Category)]
        public object mm256_permute2f128_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Permute2x128);
        
        /// <summary>
        /// Shuffle 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) selected by "imm8" from "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
        ///VPERM2F128 ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute2f128_ps", Category)]
        public object mm256_permute2f128_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Permute2x128);
        
        /// <summary>
        /// Shuffle 128-bits (composed of integer data) selected by "imm8" from "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
        ///VPERM2F128 ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute2f128_si256", Category)]
        public object mm256_permute2f128_si256(object a, object b, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Permute2x128);
        
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements in "a" within 128-bit lanes using the control in "b", and store the results in "dst".
        ///
        ///__m256d _mm256_permutevar_pd (__m256d a, __m256i b)
        ///VPERMILPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_permutevar_pd", Category)]
        public object mm256_permutevar_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, long, System.Runtime.Intrinsics.Vector256<long>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.PermuteVar);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" within 128-bit lanes using the control in "b", and store the results in "dst".
        ///
        ///__m256 _mm256_permutevar_ps (__m256 a, __m256i b)
        ///VPERMILPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_permutevar_ps", Category)]
        public object mm256_permutevar_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, int, System.Runtime.Intrinsics.Vector256<int>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.PermuteVar);
        
        /// <summary>
        /// Compute the approximate reciprocal of packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m256 _mm256_rcp_ps (__m256 a)
        ///VRCPPS ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_rcp_ps", Category)]
        public object mm256_rcp_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.Reciprocal);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_round_pd (__m256d a, _MM_FROUND_CUR_DIRECTION)
        ///VROUNDPD ymm, ymm/m256, imm8(4)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_pd1", Category)]
        public object mm256_round_pd1(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.RoundCurrentDirection);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)
        ///VROUNDPD ymm, ymm/m256, imm8(8)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_pd1_to_nearest_integer", Category)]
        public object mm256_round_pd1_to_nearest_integer(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToNearestInteger);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)
        ///VROUNDPD ymm, ymm/m256, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_pd1_to_negative_infinity", Category)]
        public object mm256_round_pd1_to_negative_infinity(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToNegativeInfinity);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)
        ///VROUNDPD ymm, ymm/m256, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_pd1_to_positive_infinity", Category)]
        public object mm256_round_pd1_to_positive_infinity(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToPositiveInfinity);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)
        ///VROUNDPD ymm, ymm/m256, imm8(11)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_pd1_to_zero", Category)]
        public object mm256_round_pd1_to_zero(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToZero);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_round_ps (__m256 a, _MM_FROUND_CUR_DIRECTION)
        ///VROUNDPS ymm, ymm/m256, imm8(4)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_ps", Category)]
        public object mm256_round_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.RoundCurrentDirection);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)
        ///VROUNDPS ymm, ymm/m256, imm8(8)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_ps_to_nearest_integer", Category)]
        public object mm256_round_ps_to_nearest_integer(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToNearestInteger);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)
        ///VROUNDPS ymm, ymm/m256, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_ps_to_negative_infinity", Category)]
        public object mm256_round_ps_to_negative_infinity(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToNegativeInfinity);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)
        ///VROUNDPS ymm, ymm/m256, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_ps_to_positive_infinity", Category)]
        public object mm256_round_ps_to_positive_infinity(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToPositiveInfinity);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)
        ///VROUNDPS ymm, ymm/m256, imm8(11)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_round_ps_to_zero", Category)]
        public object mm256_round_ps_to_zero(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.RoundToZero);
        
        /// <summary>
        /// Compute the approximate reciprocal square root of packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m256 _mm256_rsqrt_ps (__m256 a)
        ///VRSQRTPS ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_rsqrt_ps", Category)]
        public object mm256_rsqrt_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.ReciprocalSqrt);
        
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements within 128-bit lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8)
        ///VSHUFPD ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_shuffle_pd", Category)]
        public object mm256_shuffle_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Shuffle);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" within 128-bit lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)
        ///VSHUFPS ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_shuffle_ps", Category)]
        public object mm256_shuffle_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx.Shuffle);
        
        /// <summary>
        /// Compute the square root of packed double-precision (64-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m256d _mm256_sqrt_pd (__m256d a)
        ///VSQRTPD ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_sqrt_pd", Category)]
        public object mm256_sqrt_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx.Sqrt);
        
        /// <summary>
        /// Compute the square root of packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m256 _mm256_sqrt_ps (__m256 a)
        ///VSQRTPS ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_sqrt_ps", Category)]
        public object mm256_sqrt_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx.Sqrt);
        
        /// <summary>
        /// Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm256_store_pd (double * mem_addr, __m256d a)
        ///VMOVAPD m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_store_pd", Category)]
        public void mm256_store_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, 32, a, Avx_StoreAligned731);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_StoreAligned731 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.StoreAligned((double*)arg0, (System.Runtime.Intrinsics.Vector256<double>)arg1));
        /// <summary>
        /// Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm256_store_ps (float * mem_addr, __m256 a)
        ///VMOVAPS m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_store_ps", Category)]
        public void mm256_store_ps(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, 32, a, Avx_StoreAligned736);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_StoreAligned736 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.StoreAligned((float*)arg0, (System.Runtime.Intrinsics.Vector256<float>)arg1));
        /// <summary>
        /// Store 256-bits of integer data from "a" into memory.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm256_store_si256 (__m256i * mem_addr, __m256i a)
        ///MOVDQA m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_store_si256", Category)]
        public void mm256_store_si256(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, 32, a, Avx_StoreAligned730);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx_StoreAligned730 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.StoreAligned((byte*)arg0, (System.Runtime.Intrinsics.Vector256<byte>)arg1));
        /// <summary>
        /// Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm256_storeu_pd (double * mem_addr, __m256d a)
        ///MOVUPD m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_storeu_pd", Category)]
        public void mm256_storeu_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, a, Avx_Store721);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_Store721 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.Store((double*)arg0, (System.Runtime.Intrinsics.Vector256<double>)arg1));
        /// <summary>
        /// Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm256_storeu_ps (float * mem_addr, __m256 a)
        ///MOVUPS m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_storeu_ps", Category)]
        public void mm256_storeu_ps(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, a, Avx_Store726);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_Store726 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.Store((float*)arg0, (System.Runtime.Intrinsics.Vector256<float>)arg1));
        /// <summary>
        /// Store 256-bits of integer data from "a" into memory.
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a)
        ///MOVDQU m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_storeu_si256", Category)]
        public void mm256_storeu_si256(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, a, Avx_Store720);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx_Store720 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.Store((byte*)arg0, (System.Runtime.Intrinsics.Vector256<byte>)arg1));
        /// <summary>
        /// Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from "a" into memory using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm256_stream_pd (double * mem_addr, __m256d a)
        ///MOVNTPD m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_stream_pd", Category)]
        public void mm256_stream_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector256<double>>(mem_addr, 32, a, Avx_StoreAlignedNonTemporal741);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>> Avx_StoreAlignedNonTemporal741 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.StoreAlignedNonTemporal((double*)arg0, (System.Runtime.Intrinsics.Vector256<double>)arg1));
        /// <summary>
        /// Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from "a" into memory using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm256_stream_ps (float * mem_addr, __m256 a)
        ///MOVNTPS m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_stream_ps", Category)]
        public void mm256_stream_ps(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector256<float>>(mem_addr, 32, a, Avx_StoreAlignedNonTemporal746);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>> Avx_StoreAlignedNonTemporal746 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.StoreAlignedNonTemporal((float*)arg0, (System.Runtime.Intrinsics.Vector256<float>)arg1));
        /// <summary>
        /// Store 256-bits of integer data from "a" into memory using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm256_stream_si256 (__m256i * mem_addr, __m256i a)
        ///VMOVNTDQ m256, ymm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_stream_si256", Category)]
        public void mm256_stream_si256(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, 32, a, Avx_StoreAlignedNonTemporal740);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx_StoreAlignedNonTemporal740 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx.StoreAlignedNonTemporal((byte*)arg0, (System.Runtime.Intrinsics.Vector256<byte>)arg1));
        /// <summary>
        /// Subtract packed double-precision (64-bit) floating-point elements in "b" from packed double-precision (64-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m256d _mm256_sub_pd (__m256d a, __m256d b)
        ///VSUBPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sub_pd", Category)]
        public object mm256_sub_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Subtract);
        
        /// <summary>
        /// Subtract packed single-precision (32-bit) floating-point elements in "b" from packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m256 _mm256_sub_ps (__m256 a, __m256 b)
        ///VSUBPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sub_ps", Category)]
        public object mm256_sub_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Subtract);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing double-precision (64-bit) floating-point elements) in "a" and "b", producing an intermediate 256-bit value, and set "ZF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "CF" value.
        ///
        ///int _mm256_testc_pd (__m256d a, __m256d b)
        ///VTESTPS ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testc_pd", Category)]
        public KalkBool mm256_testc_pd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestC);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing single-precision (32-bit) floating-point elements) in "a" and "b", producing an intermediate 256-bit value, and set "ZF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "CF" value.
        ///
        ///int _mm256_testc_ps (__m256 a, __m256 b)
        ///VTESTPS ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testc_ps", Category)]
        public KalkBool mm256_testc_ps(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestC);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return the "CF" value.
        ///
        ///int _mm256_testc_si256 (__m256i a, __m256i b)
        ///VPTEST ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testc_si256", Category)]
        public KalkBool mm256_testc_si256(object a, object b) => (KalkBool)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestC);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing double-precision (64-bit) floating-point elements) in "a" and "b", producing an intermediate 256-bit value, and set "ZF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.
        ///
        ///int _mm256_testnzc_pd (__m256d a, __m256d b)
        ///VTESTPD ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testnzc_pd", Category)]
        public KalkBool mm256_testnzc_pd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestNotZAndNotC);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing single-precision (32-bit) floating-point elements) in "a" and "b", producing an intermediate 256-bit value, and set "ZF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.
        ///
        ///int _mm256_testnzc_ps (__m256 a, __m256 b)
        ///VTESTPS ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testnzc_ps", Category)]
        public KalkBool mm256_testnzc_ps(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestNotZAndNotC);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.
        ///
        ///int _mm256_testnzc_si256 (__m256i a, __m256i b)
        ///VPTEST ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testnzc_si256", Category)]
        public KalkBool mm256_testnzc_si256(object a, object b) => (KalkBool)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestNotZAndNotC);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing double-precision (64-bit) floating-point elements) in "a" and "b", producing an intermediate 256-bit value, and set "ZF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "ZF" value.
        ///
        ///int _mm256_testz_pd (__m256d a, __m256d b)
        ///VTESTPD ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testz_pd", Category)]
        public KalkBool mm256_testz_pd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestZ);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing single-precision (32-bit) floating-point elements) in "a" and "b", producing an intermediate 256-bit value, and set "ZF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", producing an intermediate value, and set "CF" to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set "CF" to 0. Return the "ZF" value.
        ///
        ///int _mm256_testz_ps (__m256 a, __m256 b)
        ///VTESTPS ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testz_ps", Category)]
        public KalkBool mm256_testz_ps(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestZ);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return the "ZF" value.
        ///
        ///int _mm256_testz_si256 (__m256i a, __m256i b)
        ///VPTEST ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_testz_si256", Category)]
        public KalkBool mm256_testz_si256(object a, object b) => (KalkBool)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Avx.TestZ);
        
        /// <summary>
        /// Unpack and interleave double-precision (64-bit) floating-point elements from the high half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_unpackhi_pd (__m256d a, __m256d b)
        ///VUNPCKHPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpackhi_pd", Category)]
        public object mm256_unpackhi_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave single-precision (32-bit) floating-point elements from the high half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_unpackhi_ps (__m256 a, __m256 b)
        ///VUNPCKHPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpackhi_ps", Category)]
        public object mm256_unpackhi_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave double-precision (64-bit) floating-point elements from the low half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_unpacklo_pd (__m256d a, __m256d b)
        ///VUNPCKLPD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpacklo_pd", Category)]
        public object mm256_unpacklo_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave single-precision (32-bit) floating-point elements from the low half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_unpacklo_ps (__m256 a, __m256 b)
        ///VUNPCKLPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpacklo_ps", Category)]
        public object mm256_unpacklo_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.UnpackLow);
        
        /// <summary>
        /// Compute the bitwise XOR of packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256d _mm256_xor_pd (__m256d a, __m256d b)
        ///VXORPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_xor_pd", Category)]
        public object mm256_xor_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, b, System.Runtime.Intrinsics.X86.Avx.Xor);
        
        /// <summary>
        /// Compute the bitwise XOR of packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m256 _mm256_xor_ps (__m256 a, __m256 b)
        ///VXORPS ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_xor_ps", Category)]
        public object mm256_xor_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, b, System.Runtime.Intrinsics.X86.Avx.Xor);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Avx2IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / AVX2";

        /// <summary>
        /// Blend packed 32-bit integers from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
        ///VPBLENDD xmm, xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_blend_epi32", Category)]
        public object mm_blend_epi32(object a, object b, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx2.Blend);
        
        /// <summary>
        /// Broadcast the low packed 8-bit integer from "a" to all elements of "dst".
        ///
        ///__m128i _mm_broadcastb_epi8 (__m128i a)
        ///VPBROADCASTB xmm, m8
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_broadcastb_epi8", Category)]
        public object mm_broadcastb_epi8(object a) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, Avx2_BroadcastScalarToVector128849);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Avx2_BroadcastScalarToVector128849 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector128((byte*)arg0));
        /// <summary>
        /// Broadcast the low packed 32-bit integer from "a" to all elements of "dst".
        ///
        ///__m128i _mm_broadcastd_epi32 (__m128i a)
        ///VPBROADCASTD xmm, m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_broadcastd_epi32", Category)]
        public object mm_broadcastd_epi32(object a) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(a, Avx2_BroadcastScalarToVector128851);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>> Avx2_BroadcastScalarToVector128851 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector128((int*)arg0));
        /// <summary>
        /// Broadcast the low packed 64-bit integer from "a" to all elements of "dst".
        ///
        ///__m128i _mm_broadcastq_epi64 (__m128i a)
        ///VPBROADCASTQ xmm, m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_broadcastq_epi64", Category)]
        public object mm_broadcastq_epi64(object a) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(a, Avx2_BroadcastScalarToVector128852);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>> Avx2_BroadcastScalarToVector128852 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector128((long*)arg0));
        /// <summary>
        /// Broadcast the low double-precision (64-bit) floating-point element from "a" to all elements of "dst".
        ///
        ///__m128d _mm_broadcastsd_pd (__m128d a)
        ///VMOVDDUP xmm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_broadcastsd_pd", Category)]
        public object mm_broadcastsd_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector128);
        
        /// <summary>
        /// Broadcast the low single-precision (32-bit) floating-point element from "a" to all elements of "dst".
        ///
        ///__m128 _mm_broadcastss_ps (__m128 a)
        ///VBROADCASTSS xmm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_broadcastss_ps", Category)]
        public object mm_broadcastss_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector128);
        
        /// <summary>
        /// Broadcast the low packed 16-bit integer from "a" to all elements of "dst".
        ///
        ///__m128i _mm_broadcastw_epi16 (__m128i a)
        ///VPBROADCASTW xmm, m16
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_broadcastw_epi16", Category)]
        public object mm_broadcastw_epi16(object a) => (object)ProcessFunc<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector128<short>>(a, Avx2_BroadcastScalarToVector128850);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<short>> Avx2_BroadcastScalarToVector128850 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<short>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector128((short*)arg0));
        /// <summary>
        /// Gather 32-bit integers from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
        ///VPGATHERDD xmm, vm32x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i32gather_epi32", Category)]
        public object mm_i32gather_epi32(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(base_addr, vindex, scale, Avx2_GatherVector128953);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>> Avx2_GatherVector128953 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((int*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 64-bit integers from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
        ///VPGATHERDQ xmm, vm32x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i32gather_epi64", Category)]
        public object mm_i32gather_epi64(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(base_addr, vindex, scale, Avx2_GatherVector128956);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<long>> Avx2_GatherVector128956 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((long*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
        ///VGATHERDPD xmm, vm32x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i32gather_pd", Category)]
        public object mm_i32gather_pd(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(base_addr, vindex, scale, Avx2_GatherVector128951);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<double>> Avx2_GatherVector128951 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((double*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale)
        ///VGATHERDPS xmm, vm32x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i32gather_ps", Category)]
        public object mm_i32gather_ps(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(base_addr, vindex, scale, Avx2_GatherVector128958);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<float>> Avx2_GatherVector128958 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((float*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
        ///VPGATHERQD xmm, vm64x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i64gather_epi32", Category)]
        public object mm_i64gather_epi32(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(base_addr, vindex, scale, Avx2_GatherVector128954);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<int>> Avx2_GatherVector128954 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((int*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 64-bit integers from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
        ///VPGATHERQQ xmm, vm64x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i64gather_epi64", Category)]
        public object mm_i64gather_epi64(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(base_addr, vindex, scale, Avx2_GatherVector128957);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<long>> Avx2_GatherVector128957 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((long*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale)
        ///VGATHERQPD xmm, vm64x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i64gather_pd", Category)]
        public object mm_i64gather_pd(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(base_addr, vindex, scale, Avx2_GatherVector128952);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<double>> Avx2_GatherVector128952 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((double*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale)
        ///VGATHERQPS xmm, vm64x, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_i64gather_ps", Category)]
        public object mm_i64gather_ps(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(base_addr, vindex, scale, Avx2_GatherVector128959);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<float>> Avx2_GatherVector128959 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((float*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 32-bit integers from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
        ///VPGATHERDD xmm, vm32x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i32gather_epi32", Category)]
        public object mm_mask_i32gather_epi32(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128929);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<int>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>> Avx2_GatherMaskVector128929 = new Func<System.Runtime.Intrinsics.Vector128<int>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<int>)arg0, (int*)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2, (System.Runtime.Intrinsics.Vector128<int>)arg3, (byte)arg4));
        /// <summary>
        /// Gather 64-bit integers from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
        ///VPGATHERDQ xmm, vm32x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i32gather_epi64", Category)]
        public object mm_mask_i32gather_epi64(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128932);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<long>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<long>> Avx2_GatherMaskVector128932 = new Func<System.Runtime.Intrinsics.Vector128<long>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<long>)arg0, (long*)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2, (System.Runtime.Intrinsics.Vector128<long>)arg3, (byte)arg4));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
        ///VGATHERDPD xmm, vm32x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i32gather_pd", Category)]
        public object mm_mask_i32gather_pd(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128927);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<double>, byte, System.Runtime.Intrinsics.Vector128<double>> Avx2_GatherMaskVector128927 = new Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<double>, byte, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<double>)arg0, (double*)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2, (System.Runtime.Intrinsics.Vector128<double>)arg3, (byte)arg4));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
        ///VGATHERDPS xmm, vm32x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i32gather_ps", Category)]
        public object mm_mask_i32gather_ps(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128934);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<float>, byte, System.Runtime.Intrinsics.Vector128<float>> Avx2_GatherMaskVector128934 = new Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<float>, byte, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<float>)arg0, (float*)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2, (System.Runtime.Intrinsics.Vector128<float>)arg3, (byte)arg4));
        /// <summary>
        /// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
        ///VPGATHERQD xmm, vm64x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i64gather_epi32", Category)]
        public object mm_mask_i64gather_epi32(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128930);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<int>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>> Avx2_GatherMaskVector128930 = new Func<System.Runtime.Intrinsics.Vector128<int>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<int>)arg0, (int*)arg1, (System.Runtime.Intrinsics.Vector128<long>)arg2, (System.Runtime.Intrinsics.Vector128<int>)arg3, (byte)arg4));
        /// <summary>
        /// Gather 64-bit integers from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
        ///VPGATHERQQ xmm, vm64x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i64gather_epi64", Category)]
        public object mm_mask_i64gather_epi64(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128933);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<long>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<long>> Avx2_GatherMaskVector128933 = new Func<System.Runtime.Intrinsics.Vector128<long>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<long>, byte, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<long>)arg0, (long*)arg1, (System.Runtime.Intrinsics.Vector128<long>)arg2, (System.Runtime.Intrinsics.Vector128<long>)arg3, (byte)arg4));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
        ///VGATHERQPD xmm, vm64x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i64gather_pd", Category)]
        public object mm_mask_i64gather_pd(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128928);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<double>, byte, System.Runtime.Intrinsics.Vector128<double>> Avx2_GatherMaskVector128928 = new Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<double>, byte, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<double>)arg0, (double*)arg1, (System.Runtime.Intrinsics.Vector128<long>)arg2, (System.Runtime.Intrinsics.Vector128<double>)arg3, (byte)arg4));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
        ///VGATHERQPS xmm, vm64x, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm_mask_i64gather_ps", Category)]
        public object mm_mask_i64gather_ps(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128935);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<float>, byte, System.Runtime.Intrinsics.Vector128<float>> Avx2_GatherMaskVector128935 = new Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<float>, byte, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<float>)arg0, (float*)arg1, (System.Runtime.Intrinsics.Vector128<long>)arg2, (System.Runtime.Intrinsics.Vector128<float>)arg3, (byte)arg4));
        /// <summary>
        /// Load packed 32-bit integers from memory into "dst" using "mask" (elements are zeroed out when the highest bit is not set in the corresponding element).
        ///
        ///__m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask)
        ///VPMASKMOVD xmm, xmm, m128
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_maskload_epi32", Category)]
        public object mm_maskload_epi32(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(mem_addr, mask, Avx2_MaskLoad997);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<int>> Avx2_MaskLoad997 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx2.MaskLoad((int*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1));
        /// <summary>
        /// Load packed 64-bit integers from memory into "dst" using "mask" (elements are zeroed out when the highest bit is not set in the corresponding element).
        ///
        ///__m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask)
        ///VPMASKMOVQ xmm, xmm, m128
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_maskload_epi64", Category)]
        public object mm_maskload_epi64(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(mem_addr, mask, Avx2_MaskLoad999);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<long>> Avx2_MaskLoad999 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx2.MaskLoad((long*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1));
        /// <summary>
        /// Store packed 32-bit integers from "a" into memory using "mask" (elements are not stored when the highest bit is not set in the corresponding element).
        ///
        ///void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a)
        ///VPMASKMOVD m128, xmm, xmm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_maskstore_epi32", Category)]
        public void mm_maskstore_epi32(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(mem_addr, mask, a, Avx2_MaskStore1005);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<int>> Avx2_MaskStore1005 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.MaskStore((int*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2));
        /// <summary>
        /// Store packed 64-bit integers from "a" into memory using "mask" (elements are not stored when the highest bit is not set in the corresponding element).
        ///
        ///void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a)
        ///VPMASKMOVQ m128, xmm, xmm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_maskstore_epi64", Category)]
        public void mm_maskstore_epi64(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(mem_addr, mask, a, Avx2_MaskStore1007);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<long>> Avx2_MaskStore1007 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.MaskStore((long*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1, (System.Runtime.Intrinsics.Vector128<long>)arg2));
        /// <summary>
        /// Shift packed 32-bit integers in "a" left by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_sllv_epi32 (__m128i a, __m128i count)
        ///VPSLLVD xmm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sllv_epi32", Category)]
        public object mm_sllv_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>, int, System.Runtime.Intrinsics.Vector128<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogicalVariable);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" left by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_sllv_epi64 (__m128i a, __m128i count)
        ///VPSLLVQ xmm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sllv_epi64", Category)]
        public object mm_sllv_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, long, System.Runtime.Intrinsics.Vector128<long>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogicalVariable);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by the amount specified by the corresponding element in "count" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m128i _mm_srav_epi32 (__m128i a, __m128i count)
        ///VPSRAVD xmm, xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_srav_epi32", Category)]
        public object mm_srav_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>, int, System.Runtime.Intrinsics.Vector128<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightArithmeticVariable);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srlv_epi32 (__m128i a, __m128i count)
        ///VPSRLVD xmm, xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_srlv_epi32", Category)]
        public object mm_srlv_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>, int, System.Runtime.Intrinsics.Vector128<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogicalVariable);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" right by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srlv_epi64 (__m128i a, __m128i count)
        ///VPSRLVQ xmm, xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_srlv_epi64", Category)]
        public object mm_srlv_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, ulong, System.Runtime.Intrinsics.Vector128<ulong>, long, System.Runtime.Intrinsics.Vector128<long>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogicalVariable);
        
        /// <summary>
        /// Compute the absolute value of packed 16-bit integers in "a", and store the unsigned results in "dst".
        ///
        ///__m256i _mm256_abs_epi16 (__m256i a)
        ///VPABSW ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_abs_epi16", Category)]
        public object mm256_abs_epi16(object a) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, System.Runtime.Intrinsics.X86.Avx2.Abs);
        
        /// <summary>
        /// Compute the absolute value of packed 32-bit integers in "a", and store the unsigned results in "dst".
        ///
        ///__m256i _mm256_abs_epi32 (__m256i a)
        ///VPABSD ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_abs_epi32", Category)]
        public object mm256_abs_epi32(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, uint, System.Runtime.Intrinsics.Vector256<uint>>(a, System.Runtime.Intrinsics.X86.Avx2.Abs);
        
        /// <summary>
        /// Compute the absolute value of packed 8-bit integers in "a", and store the unsigned results in "dst".
        ///
        ///__m256i _mm256_abs_epi8 (__m256i a)
        ///VPABSB ymm, ymm/m256
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_abs_epi8", Category)]
        public object mm256_abs_epi8(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, System.Runtime.Intrinsics.X86.Avx2.Abs);
        
        /// <summary>
        /// Add packed 16-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_add_epi16 (__m256i a, __m256i b)
        ///VPADDW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_add_epi16", Category)]
        public object mm256_add_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Add);
        
        /// <summary>
        /// Add packed 32-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_add_epi32 (__m256i a, __m256i b)
        ///VPADDD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_add_epi32", Category)]
        public object mm256_add_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Add);
        
        /// <summary>
        /// Add packed 64-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_add_epi64 (__m256i a, __m256i b)
        ///VPADDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_add_epi64", Category)]
        public object mm256_add_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Add);
        
        /// <summary>
        /// Add packed 8-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_add_epi8 (__m256i a, __m256i b)
        ///VPADDB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_add_epi8", Category)]
        public object mm256_add_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Add);
        
        /// <summary>
        /// Add packed 16-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_adds_epi16 (__m256i a, __m256i b)
        ///VPADDSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_adds_epi16", Category)]
        public object mm256_adds_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.AddSaturate);
        
        /// <summary>
        /// Add packed 8-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_adds_epi8 (__m256i a, __m256i b)
        ///VPADDSB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_adds_epi8", Category)]
        public object mm256_adds_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.AddSaturate);
        
        /// <summary>
        /// Add packed unsigned 16-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_adds_epu16 (__m256i a, __m256i b)
        ///VPADDUSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_adds_epu16", Category)]
        public object mm256_adds_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.AddSaturate);
        
        /// <summary>
        /// Add packed unsigned 8-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_adds_epu8 (__m256i a, __m256i b)
        ///VPADDUSB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_adds_epu8", Category)]
        public object mm256_adds_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.AddSaturate);
        
        /// <summary>
        /// Concatenate pairs of 16-byte blocks in "a" and "b" into a 32-byte temporary result, shift the result right by "count" bytes, and store the low 16 bytes in "dst".
        ///
        ///__m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
        ///VPALIGNR ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_alignr_epi8", Category)]
        public object mm256_alignr_epi8(object a, object b, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, count, System.Runtime.Intrinsics.X86.Avx2.AlignRight);
        
        /// <summary>
        /// Compute the bitwise AND of 256 bits (representing integer data) in "a" and "b", and store the result in "dst".
        ///
        ///__m256i _mm256_and_si256 (__m256i a, __m256i b)
        ///VPAND ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_and_si256", Category)]
        public object mm256_and_si256(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.And);
        
        /// <summary>
        /// Compute the bitwise NOT of 256 bits (representing integer data) in "a" and then AND with "b", and store the result in "dst".
        ///
        ///__m256i _mm256_andnot_si256 (__m256i a, __m256i b)
        ///VPANDN ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_andnot_si256", Category)]
        public object mm256_andnot_si256(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.AndNot);
        
        /// <summary>
        /// Average packed unsigned 16-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_avg_epu16 (__m256i a, __m256i b)
        ///VPAVGW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_avg_epu16", Category)]
        public object mm256_avg_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Average);
        
        /// <summary>
        /// Average packed unsigned 8-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_avg_epu8 (__m256i a, __m256i b)
        ///VPAVGB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_avg_epu8", Category)]
        public object mm256_avg_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Average);
        
        /// <summary>
        /// Blend packed 16-bit integers from "a" and "b" within 128-bit lanes using control mask "imm8", and store the results in "dst".
        ///
        ///__m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
        ///VPBLENDW ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_blend_epi16", Category)]
        public object mm256_blend_epi16(object a, object b, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, byte, byte, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx2.Blend);
        
        /// <summary>
        /// Blend packed 32-bit integers from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
        ///VPBLENDD ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_blend_epi32", Category)]
        public object mm256_blend_epi32(object a, object b, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx2.Blend);
        
        /// <summary>
        /// Blend packed 8-bit integers from "a" and "b" using "mask", and store the results in "dst".
        ///
        ///__m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
        ///VPBLENDVB ymm, ymm, ymm/m256, ymm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_blendv_epi8", Category)]
        public object mm256_blendv_epi8(object a, object b, object mask) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, mask, System.Runtime.Intrinsics.X86.Avx2.BlendVariable);
        
        /// <summary>
        /// Broadcast the low packed 8-bit integer from "a" to all elements of "dst".
        ///
        ///__m256i _mm256_broadcastb_epi8 (__m128i a)
        ///VPBROADCASTB ymm, m8
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastb_epi8", Category)]
        public object mm256_broadcastb_epi8(object a) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, Avx2_BroadcastScalarToVector256867);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx2_BroadcastScalarToVector256867 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector256((byte*)arg0));
        /// <summary>
        /// Broadcast the low packed 32-bit integer from "a" to all elements of "dst".
        ///
        ///__m256i _mm256_broadcastd_epi32 (__m128i a)
        ///VPBROADCASTD ymm, m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastd_epi32", Category)]
        public object mm256_broadcastd_epi32(object a) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>>(a, Avx2_BroadcastScalarToVector256869);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>> Avx2_BroadcastScalarToVector256869 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector256((int*)arg0));
        /// <summary>
        /// Broadcast the low packed 64-bit integer from "a" to all elements of "dst".
        ///
        ///__m256i _mm256_broadcastq_epi64 (__m128i a)
        ///VPBROADCASTQ ymm, m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastq_epi64", Category)]
        public object mm256_broadcastq_epi64(object a) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>>(a, Avx2_BroadcastScalarToVector256870);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>> Avx2_BroadcastScalarToVector256870 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector256((long*)arg0));
        /// <summary>
        /// Broadcast the low double-precision (64-bit) floating-point element from "a" to all elements of "dst".
        ///
        ///__m256d _mm256_broadcastsd_pd (__m128d a)
        ///VBROADCASTSD ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastsd_pd", Category)]
        public object mm256_broadcastsd_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector256<double>>(a, System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector256);
        
        /// <summary>
        /// Broadcast 128 bits of integer data from "a" to all 128-bit lanes in "dst".
        ///
        ///__m256i _mm256_broadcastsi128_si256 (__m128i a)
        ///VBROADCASTI128 ymm, m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastsi128_si256", Category)]
        public object mm256_broadcastsi128_si256(object a) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, Avx2_BroadcastVector128ToVector256885);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx2_BroadcastVector128ToVector256885 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastVector128ToVector256((byte*)arg0));
        /// <summary>
        /// Broadcast the low single-precision (32-bit) floating-point element from "a" to all elements of "dst".
        ///
        ///__m256 _mm256_broadcastss_ps (__m128 a)
        ///VBROADCASTSS ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastss_ps", Category)]
        public object mm256_broadcastss_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector256<float>>(a, System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector256);
        
        /// <summary>
        /// Broadcast the low packed 16-bit integer from "a" to all elements of "dst".
        ///
        ///__m256i _mm256_broadcastw_epi16 (__m128i a)
        ///VPBROADCASTW ymm, m16
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_broadcastw_epi16", Category)]
        public object mm256_broadcastw_epi16(object a) => (object)ProcessFunc<IntPtr, IntPtr, short, System.Runtime.Intrinsics.Vector256<short>>(a, Avx2_BroadcastScalarToVector256868);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<short>> Avx2_BroadcastScalarToVector256868 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<short>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.BroadcastScalarToVector256((short*)arg0));
        /// <summary>
        /// Shift 128-bit lanes in "a" left by "imm8" bytes while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
        ///VPSLLDQ ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_bslli_epi128", Category)]
        public object mm256_bslli_epi128(object a, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical128BitLane);
        
        /// <summary>
        /// Shift 128-bit lanes in "a" right by "imm8" bytes while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
        ///VPSRLDQ ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_bsrli_epi128", Category)]
        public object mm256_bsrli_epi128(object a, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical128BitLane);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b)
        ///VPCMPEQW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpeq_epi16", Category)]
        public object mm256_cmpeq_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareEqual);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b)
        ///VPCMPEQD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpeq_epi32", Category)]
        public object mm256_cmpeq_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareEqual);
        
        /// <summary>
        /// Compare packed 64-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b)
        ///VPCMPEQQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpeq_epi64", Category)]
        public object mm256_cmpeq_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareEqual);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b)
        ///VPCMPEQB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpeq_epi8", Category)]
        public object mm256_cmpeq_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareEqual);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b)
        ///VPCMPGTW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpgt_epi16", Category)]
        public object mm256_cmpgt_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareGreaterThan);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b)
        ///VPCMPGTD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpgt_epi32", Category)]
        public object mm256_cmpgt_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareGreaterThan);
        
        /// <summary>
        /// Compare packed 64-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b)
        ///VPCMPGTQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpgt_epi64", Category)]
        public object mm256_cmpgt_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareGreaterThan);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b)
        ///VPCMPGTB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_cmpgt_epi8", Category)]
        public object mm256_cmpgt_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.CompareGreaterThan);
        
        /// <summary>
        /// Sign extend packed 16-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepi16_epi32 (__m128i a)
        ///VPMOVSXWD ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi16_epi32", Category)]
        public object mm256_cvtepi16_epi32(object a) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector256<int>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int32);
        
        /// <summary>
        /// Sign extend packed 16-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepi16_epi64 (__m128i a)
        ///VPMOVSXWQ ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi16_epi64", Category)]
        public object mm256_cvtepi16_epi64(object a) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, long, System.Runtime.Intrinsics.Vector256<long>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int64);
        
        /// <summary>
        /// Sign extend packed 32-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepi32_epi64 (__m128i a)
        ///VPMOVSXDQ ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi32_epi64", Category)]
        public object mm256_cvtepi32_epi64(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector256<long>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int64);
        
        /// <summary>
        /// Sign extend packed 8-bit integers in "a" to packed 16-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepi8_epi16 (__m128i a)
        ///VPMOVSXBW ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi8_epi16", Category)]
        public object mm256_cvtepi8_epi16(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector256<short>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int16);
        
        /// <summary>
        /// Sign extend packed 8-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepi8_epi32 (__m128i a)
        ///VPMOVSXBD ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi8_epi32", Category)]
        public object mm256_cvtepi8_epi32(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, int, System.Runtime.Intrinsics.Vector256<int>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int32);
        
        /// <summary>
        /// Sign extend packed 8-bit integers in the low 8 bytes of "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepi8_epi64 (__m128i a)
        ///VPMOVSXBQ ymm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepi8_epi64", Category)]
        public object mm256_cvtepi8_epi64(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, long, System.Runtime.Intrinsics.Vector256<long>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int64);
        
        /// <summary>
        /// Zero extend packed unsigned 16-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepu16_epi32 (__m128i a)
        ///VPMOVZXWD ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepu16_epi32", Category)]
        public object mm256_cvtepu16_epi32(object a) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, int, System.Runtime.Intrinsics.Vector256<int>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int32);
        
        /// <summary>
        /// Zero extend packed unsigned 16-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepu16_epi64 (__m128i a)
        ///VPMOVZXWQ ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepu16_epi64", Category)]
        public object mm256_cvtepu16_epi64(object a) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, long, System.Runtime.Intrinsics.Vector256<long>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int64);
        
        /// <summary>
        /// Zero extend packed unsigned 32-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepu32_epi64 (__m128i a)
        ///VPMOVZXDQ ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepu32_epi64", Category)]
        public object mm256_cvtepu32_epi64(object a) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, long, System.Runtime.Intrinsics.Vector256<long>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int64);
        
        /// <summary>
        /// Zero extend packed unsigned 8-bit integers in "a" to packed 16-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepu8_epi16 (__m128i a)
        ///VPMOVZXBW ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepu8_epi16", Category)]
        public object mm256_cvtepu8_epi16(object a) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, short, System.Runtime.Intrinsics.Vector256<short>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int16);
        
        /// <summary>
        /// Zero extend packed unsigned 8-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepu8_epi32 (__m128i a)
        ///VPMOVZXBD ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepu8_epi32", Category)]
        public object mm256_cvtepu8_epi32(object a) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, int, System.Runtime.Intrinsics.Vector256<int>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int32);
        
        /// <summary>
        /// Zero extend packed unsigned 8-bit integers in the low 8 byte sof "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m256i _mm256_cvtepu8_epi64 (__m128i a)
        ///VPMOVZXBQ ymm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtepu8_epi64", Category)]
        public object mm256_cvtepu8_epi64(object a) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, long, System.Runtime.Intrinsics.Vector256<long>>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToVector256Int64);
        
        /// <summary>
        /// Copy the lower 32-bit integer in "a" to "dst".
        ///
        ///int _mm256_cvtsi256_si32 (__m256i a)
        ///MOVD reg/m32, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_cvtsi256_si32", Category)]
        public int mm256_cvtsi256_si32(object a) => (int)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, int>(a, System.Runtime.Intrinsics.X86.Avx2.ConvertToInt32);
        
        /// <summary>
        /// Extract 128 bits (composed of integer data) from "a", selected with "imm8", and store the result in "dst".
        ///
        ///__m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
        ///VEXTRACTI128 xmm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_extracti128_si256", Category)]
        public object mm256_extracti128_si256(object a, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ExtractVector128);
        
        /// <summary>
        /// Horizontally add adjacent pairs of 16-bit integers in "a" and "b", and pack the signed 16-bit results in "dst".
        ///
        ///__m256i _mm256_hadd_epi16 (__m256i a, __m256i b)
        ///VPHADDW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hadd_epi16", Category)]
        public object mm256_hadd_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.HorizontalAdd);
        
        /// <summary>
        /// Horizontally add adjacent pairs of 32-bit integers in "a" and "b", and pack the signed 32-bit results in "dst".
        ///
        ///__m256i _mm256_hadd_epi32 (__m256i a, __m256i b)
        ///VPHADDD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hadd_epi32", Category)]
        public object mm256_hadd_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.HorizontalAdd);
        
        /// <summary>
        /// Horizontally add adjacent pairs of 16-bit integers in "a" and "b" using saturation, and pack the signed 16-bit results in "dst".
        ///
        ///__m256i _mm256_hadds_epi16 (__m256i a, __m256i b)
        ///VPHADDSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hadds_epi16", Category)]
        public object mm256_hadds_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.HorizontalAddSaturate);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of 16-bit integers in "a" and "b", and pack the signed 16-bit results in "dst".
        ///
        ///__m256i _mm256_hsub_epi16 (__m256i a, __m256i b)
        ///VPHSUBW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hsub_epi16", Category)]
        public object mm256_hsub_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.HorizontalSubtract);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of 32-bit integers in "a" and "b", and pack the signed 32-bit results in "dst".
        ///
        ///__m256i _mm256_hsub_epi32 (__m256i a, __m256i b)
        ///VPHSUBD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hsub_epi32", Category)]
        public object mm256_hsub_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.HorizontalSubtract);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of 16-bit integers in "a" and "b" using saturation, and pack the signed 16-bit results in "dst".
        ///
        ///__m256i _mm256_hsubs_epi16 (__m256i a, __m256i b)
        ///VPHSUBSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_hsubs_epi16", Category)]
        public object mm256_hsubs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.HorizontalSubtractSaturate);
        
        /// <summary>
        /// Gather 32-bit integers from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
        ///VPGATHERDD ymm, vm32y, ymm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i32gather_epi32", Category)]
        public object mm256_i32gather_epi32(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(base_addr, vindex, scale, Avx2_GatherVector256968);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>, byte, System.Runtime.Intrinsics.Vector256<int>> Avx2_GatherVector256968 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>, byte, System.Runtime.Intrinsics.Vector256<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector256((int*)arg0, (System.Runtime.Intrinsics.Vector256<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 64-bit integers from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
        ///VPGATHERDQ ymm, vm32y, ymm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i32gather_epi64", Category)]
        public object mm256_i32gather_epi64(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(base_addr, vindex, scale, Avx2_GatherVector256969);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector256<long>> Avx2_GatherVector256969 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector256<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector256((long*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
        ///VGATHERDPD ymm, vm32y, ymm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i32gather_pd", Category)]
        public object mm256_i32gather_pd(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(base_addr, vindex, scale, Avx2_GatherVector256966);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector256<double>> Avx2_GatherVector256966 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector256((double*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale)
        ///VGATHERDPS ymm, vm32y, ymm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i32gather_ps", Category)]
        public object mm256_i32gather_ps(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(base_addr, vindex, scale, Avx2_GatherVector256971);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>, byte, System.Runtime.Intrinsics.Vector256<float>> Avx2_GatherVector256971 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>, byte, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector256((float*)arg0, (System.Runtime.Intrinsics.Vector256<int>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
        ///VPGATHERQD xmm, vm64y, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i64gather_epi32", Category)]
        public object mm256_i64gather_epi32(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(base_addr, vindex, scale, Avx2_GatherVector128955);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector128<int>> Avx2_GatherVector128955 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((int*)arg0, (System.Runtime.Intrinsics.Vector256<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather 64-bit integers from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
        ///VPGATHERQQ ymm, vm64y, ymm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i64gather_epi64", Category)]
        public object mm256_i64gather_epi64(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(base_addr, vindex, scale, Avx2_GatherVector256970);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<long>> Avx2_GatherVector256970 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector256((long*)arg0, (System.Runtime.Intrinsics.Vector256<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale)
        ///VGATHERQPD ymm, vm64y, ymm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i64gather_pd", Category)]
        public object mm256_i64gather_pd(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(base_addr, vindex, scale, Avx2_GatherVector256967);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<double>> Avx2_GatherVector256967 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector256((double*)arg0, (System.Runtime.Intrinsics.Vector256<long>)arg1, (byte)arg2));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst". "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale)
        ///VGATHERQPS xmm, vm64y, xmm
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_i64gather_ps", Category)]
        public object mm256_i64gather_ps(object base_addr, object vindex, byte scale) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(base_addr, vindex, scale, Avx2_GatherVector128960);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector128<float>> Avx2_GatherVector128960 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.GatherVector128((float*)arg0, (System.Runtime.Intrinsics.Vector256<long>)arg1, (byte)arg2));
        /// <summary>
        /// Copy "a" to "dst", then insert 128 bits (composed of integer data) from "b" into "dst" at the location specified by "imm8".
        ///
        ///__m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
        ///VINSERTI128 ymm, ymm, xmm, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_inserti128_si256", Category)]
        public object mm256_inserti128_si256(object a, object b, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx2.InsertVector128);
        
        /// <summary>
        /// Multiply packed signed 16-bit integers in "a" and "b", producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in "dst".
        ///
        ///__m256i _mm256_madd_epi16 (__m256i a, __m256i b)
        ///VPMADDWD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_madd_epi16", Category)]
        public object mm256_madd_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyAddAdjacent);
        
        /// <summary>
        /// Vertically multiply each unsigned 8-bit integer from "a" with the corresponding signed 8-bit integer from "b", producing intermediate signed 16-bit integers. Horizontally add adjacent pairs of intermediate signed 16-bit integers, and pack the saturated results in "dst".
        ///
        ///__m256i _mm256_maddubs_epi16 (__m256i a, __m256i b)
        ///VPMADDUBSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_maddubs_epi16", Category)]
        public object mm256_maddubs_epi16(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyAddAdjacent);
        
        /// <summary>
        /// Gather 32-bit integers from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
        ///VPGATHERDD ymm, vm32y, ymm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i32gather_epi32", Category)]
        public object mm256_mask_i32gather_epi32(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector256944);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector256<int>, IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<int>, byte, System.Runtime.Intrinsics.Vector256<int>> Avx2_GatherMaskVector256944 = new Func<System.Runtime.Intrinsics.Vector256<int>, IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<int>, byte, System.Runtime.Intrinsics.Vector256<int>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector256((System.Runtime.Intrinsics.Vector256<int>)arg0, (int*)arg1, (System.Runtime.Intrinsics.Vector256<int>)arg2, (System.Runtime.Intrinsics.Vector256<int>)arg3, (byte)arg4));
        /// <summary>
        /// Gather 64-bit integers from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
        ///VPGATHERDQ ymm, vm32y, ymm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i32gather_epi64", Category)]
        public object mm256_mask_i32gather_epi64(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector256945);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector256<long>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<long>> Avx2_GatherMaskVector256945 = new Func<System.Runtime.Intrinsics.Vector256<long>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<long>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector256((System.Runtime.Intrinsics.Vector256<long>)arg0, (long*)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2, (System.Runtime.Intrinsics.Vector256<long>)arg3, (byte)arg4));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 32-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale)
        ///VPGATHERDPD ymm, vm32y, ymm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i32gather_pd", Category)]
        public object mm256_mask_i32gather_pd(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>, double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector256942);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector256<double>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector256<double>, byte, System.Runtime.Intrinsics.Vector256<double>> Avx2_GatherMaskVector256942 = new Func<System.Runtime.Intrinsics.Vector256<double>, IntPtr, System.Runtime.Intrinsics.Vector128<int>, System.Runtime.Intrinsics.Vector256<double>, byte, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector256((System.Runtime.Intrinsics.Vector256<double>)arg0, (double*)arg1, (System.Runtime.Intrinsics.Vector128<int>)arg2, (System.Runtime.Intrinsics.Vector256<double>)arg3, (byte)arg4));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 32-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 32-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale)
        ///VPGATHERDPS ymm, vm32y, ymm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i32gather_ps", Category)]
        public object mm256_mask_i32gather_ps(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>, float, System.Runtime.Intrinsics.Vector256<float>, byte, byte, float, System.Runtime.Intrinsics.Vector256<float>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector256947);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector256<float>, IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<float>, byte, System.Runtime.Intrinsics.Vector256<float>> Avx2_GatherMaskVector256947 = new Func<System.Runtime.Intrinsics.Vector256<float>, IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<float>, byte, System.Runtime.Intrinsics.Vector256<float>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector256((System.Runtime.Intrinsics.Vector256<float>)arg0, (float*)arg1, (System.Runtime.Intrinsics.Vector256<int>)arg2, (System.Runtime.Intrinsics.Vector256<float>)arg3, (byte)arg4));
        /// <summary>
        /// Gather 32-bit integers from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
        ///VPGATHERQD xmm, vm32y, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i64gather_epi32", Category)]
        public object mm256_mask_i64gather_epi32(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128931);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<int>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>> Avx2_GatherMaskVector128931 = new Func<System.Runtime.Intrinsics.Vector128<int>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector128<int>, byte, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<int>)arg0, (int*)arg1, (System.Runtime.Intrinsics.Vector256<long>)arg2, (System.Runtime.Intrinsics.Vector128<int>)arg3, (byte)arg4));
        /// <summary>
        /// Gather 64-bit integers from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
        ///VPGATHERQQ ymm, vm32y, ymm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i64gather_epi64", Category)]
        public object mm256_mask_i64gather_epi64(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector256946);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector256<long>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<long>> Avx2_GatherMaskVector256946 = new Func<System.Runtime.Intrinsics.Vector256<long>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<long>, byte, System.Runtime.Intrinsics.Vector256<long>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector256((System.Runtime.Intrinsics.Vector256<long>)arg0, (long*)arg1, (System.Runtime.Intrinsics.Vector256<long>)arg2, (System.Runtime.Intrinsics.Vector256<long>)arg3, (byte)arg4));
        /// <summary>
        /// Gather double-precision (64-bit) floating-point elements from memory using 64-bit indices. 64-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale)
        ///VGATHERQPD ymm, vm32y, ymm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i64gather_pd", Category)]
        public object mm256_mask_i64gather_pd(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector256943);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector256<double>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<double>, byte, System.Runtime.Intrinsics.Vector256<double>> Avx2_GatherMaskVector256943 = new Func<System.Runtime.Intrinsics.Vector256<double>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<double>, byte, System.Runtime.Intrinsics.Vector256<double>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector256((System.Runtime.Intrinsics.Vector256<double>)arg0, (double*)arg1, (System.Runtime.Intrinsics.Vector256<long>)arg2, (System.Runtime.Intrinsics.Vector256<double>)arg3, (byte)arg4));
        /// <summary>
        /// Gather single-precision (32-bit) floating-point elements from memory using 64-bit indices. 32-bit elements are loaded from addresses starting at "base_addr" and offset by each 64-bit element in "vindex" (each index is scaled by the factor in "scale"). Gathered elements are merged into "dst" using "mask" (elements are copied from "src" when the highest bit is not set in the corresponding element). "scale" should be 1, 2, 4 or 8.
        ///
        ///__m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale)
        ///VGATHERQPS xmm, vm32y, xmm
        /// <param name="src"></param>
        /// <param name="base_addr"></param>
        /// <param name="vindex"></param>
        /// <param name="mask"></param>
        /// <param name="scale"></param>
        /// </summary>
        [KalkExport("mm256_mask_i64gather_ps", Category)]
        public object mm256_mask_i64gather_ps(object src, object base_addr, object vindex, object mask, byte scale) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(src, base_addr, vindex, mask, scale, Avx2_GatherMaskVector128936);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector128<float>, byte, System.Runtime.Intrinsics.Vector128<float>> Avx2_GatherMaskVector128936 = new Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector128<float>, byte, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1, arg2, arg3, arg4) => System.Runtime.Intrinsics.X86.Avx2.GatherMaskVector128((System.Runtime.Intrinsics.Vector128<float>)arg0, (float*)arg1, (System.Runtime.Intrinsics.Vector256<long>)arg2, (System.Runtime.Intrinsics.Vector128<float>)arg3, (byte)arg4));
        /// <summary>
        /// Load packed 32-bit integers from memory into "dst" using "mask" (elements are zeroed out when the highest bit is not set in the corresponding element).
        ///
        ///__m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask)
        ///VPMASKMOVD ymm, ymm, m256
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_maskload_epi32", Category)]
        public object mm256_maskload_epi32(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(mem_addr, mask, Avx2_MaskLoad998);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<int>> Avx2_MaskLoad998 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<int>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx2.MaskLoad((int*)arg0, (System.Runtime.Intrinsics.Vector256<int>)arg1));
        /// <summary>
        /// Load packed 64-bit integers from memory into "dst" using "mask" (elements are zeroed out when the highest bit is not set in the corresponding element).
        ///
        ///__m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask)
        ///VPMASKMOVQ ymm, ymm, m256
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm256_maskload_epi64", Category)]
        public object mm256_maskload_epi64(object mem_addr, object mask) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(mem_addr, mask, Avx2_MaskLoad1000);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<long>> Avx2_MaskLoad1000 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<long>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Avx2.MaskLoad((long*)arg0, (System.Runtime.Intrinsics.Vector256<long>)arg1));
        /// <summary>
        /// Store packed 32-bit integers from "a" into memory using "mask" (elements are not stored when the highest bit is not set in the corresponding element).
        ///
        ///void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a)
        ///VPMASKMOVD m256, ymm, ymm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_maskstore_epi32", Category)]
        public void mm256_maskstore_epi32(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(mem_addr, mask, a, Avx2_MaskStore1006);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<int>> Avx2_MaskStore1006 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<int>, System.Runtime.Intrinsics.Vector256<int>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.MaskStore((int*)arg0, (System.Runtime.Intrinsics.Vector256<int>)arg1, (System.Runtime.Intrinsics.Vector256<int>)arg2));
        /// <summary>
        /// Store packed 64-bit integers from "a" into memory using "mask" (elements are not stored when the highest bit is not set in the corresponding element).
        ///
        ///void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a)
        ///VPMASKMOVQ m256, ymm, ymm
        /// <param name="mem_addr"></param>
        /// <param name="mask"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_maskstore_epi64", Category)]
        public void mm256_maskstore_epi64(object mem_addr, object mask, object a) => ProcessAction<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(mem_addr, mask, a, Avx2_MaskStore1008);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<long>> Avx2_MaskStore1008 = new Action<IntPtr, System.Runtime.Intrinsics.Vector256<long>, System.Runtime.Intrinsics.Vector256<long>>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Avx2.MaskStore((long*)arg0, (System.Runtime.Intrinsics.Vector256<long>)arg1, (System.Runtime.Intrinsics.Vector256<long>)arg2));
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256i _mm256_max_epi16 (__m256i a, __m256i b)
        ///VPMAXSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_epi16", Category)]
        public object mm256_max_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Max);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256i _mm256_max_epi32 (__m256i a, __m256i b)
        ///VPMAXSD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_epi32", Category)]
        public object mm256_max_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Max);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256i _mm256_max_epi8 (__m256i a, __m256i b)
        ///VPMAXSB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_epi8", Category)]
        public object mm256_max_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Max);
        
        /// <summary>
        /// Compare packed unsigned 16-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256i _mm256_max_epu16 (__m256i a, __m256i b)
        ///VPMAXUW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_epu16", Category)]
        public object mm256_max_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Max);
        
        /// <summary>
        /// Compare packed unsigned 32-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256i _mm256_max_epu32 (__m256i a, __m256i b)
        ///VPMAXUD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_epu32", Category)]
        public object mm256_max_epu32(object a, object b) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector256<uint>, uint, System.Runtime.Intrinsics.Vector256<uint>, uint, System.Runtime.Intrinsics.Vector256<uint>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Max);
        
        /// <summary>
        /// Compare packed unsigned 8-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m256i _mm256_max_epu8 (__m256i a, __m256i b)
        ///VPMAXUB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_max_epu8", Category)]
        public object mm256_max_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Max);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256i _mm256_min_epi16 (__m256i a, __m256i b)
        ///VPMINSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_epi16", Category)]
        public object mm256_min_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Min);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256i _mm256_min_epi32 (__m256i a, __m256i b)
        ///VPMINSD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_epi32", Category)]
        public object mm256_min_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Min);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256i _mm256_min_epi8 (__m256i a, __m256i b)
        ///VPMINSB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_epi8", Category)]
        public object mm256_min_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Min);
        
        /// <summary>
        /// Compare packed unsigned 16-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256i _mm256_min_epu16 (__m256i a, __m256i b)
        ///VPMINUW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_epu16", Category)]
        public object mm256_min_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Min);
        
        /// <summary>
        /// Compare packed unsigned 32-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256i _mm256_min_epu32 (__m256i a, __m256i b)
        ///VPMINUD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_epu32", Category)]
        public object mm256_min_epu32(object a, object b) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector256<uint>, uint, System.Runtime.Intrinsics.Vector256<uint>, uint, System.Runtime.Intrinsics.Vector256<uint>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Min);
        
        /// <summary>
        /// Compare packed unsigned 8-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m256i _mm256_min_epu8 (__m256i a, __m256i b)
        ///VPMINUB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_min_epu8", Category)]
        public object mm256_min_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Min);
        
        /// <summary>
        /// Create mask from the most significant bit of each 8-bit element in "a", and store the result in "dst".
        ///
        ///int _mm256_movemask_epi8 (__m256i a)
        ///VPMOVMSKB reg, ymm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm256_movemask_epi8", Category)]
        public int mm256_movemask_epi8(object a) => (int)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, int, int>(a, System.Runtime.Intrinsics.X86.Avx2.MoveMask);
        
        /// <summary>
        /// Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in "a" compared to those in "b", and store the 16-bit results in "dst".
        ///	Eight SADs are performed for each 128-bit lane using one quadruplet from "b" and eight quadruplets from "a". One quadruplet is selected from "b" starting at on the offset specified in "imm8". Eight quadruplets are formed from sequential 8-bit integers selected from "a" starting at the offset specified in "imm8".
        ///
        ///__m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8)
        ///VMPSADBW ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_mpsadbw_epu8", Category)]
        public object mm256_mpsadbw_epu8(object a, object b, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx2.MultipleSumAbsoluteDifferences);
        
        /// <summary>
        /// Multiply the low 32-bit integers from each packed 64-bit element in "a" and "b", and store the signed 64-bit results in "dst".
        ///
        ///__m256i _mm256_mul_epi32 (__m256i a, __m256i b)
        ///VPMULDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mul_epi32", Category)]
        public object mm256_mul_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Multiply);
        
        /// <summary>
        /// Multiply the low unsigned 32-bit integers from each packed 64-bit element in "a" and "b", and store the unsigned 64-bit results in "dst".
        ///
        ///__m256i _mm256_mul_epu32 (__m256i a, __m256i b)
        ///VPMULUDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mul_epu32", Category)]
        public object mm256_mul_epu32(object a, object b) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector256<uint>, uint, System.Runtime.Intrinsics.Vector256<uint>, ulong, System.Runtime.Intrinsics.Vector256<ulong>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Multiply);
        
        /// <summary>
        /// Multiply the packed 16-bit integers in "a" and "b", producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in "dst".
        ///
        ///__m256i _mm256_mulhi_epi16 (__m256i a, __m256i b)
        ///VPMULHW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mulhi_epi16", Category)]
        public object mm256_mulhi_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyHigh);
        
        /// <summary>
        /// Multiply the packed unsigned 16-bit integers in "a" and "b", producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in "dst".
        ///
        ///__m256i _mm256_mulhi_epu16 (__m256i a, __m256i b)
        ///VPMULHUW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mulhi_epu16", Category)]
        public object mm256_mulhi_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyHigh);
        
        /// <summary>
        /// Multiply packed 16-bit integers in "a" and "b", producing intermediate signed 32-bit integers. Truncate each intermediate integer to the 18 most significant bits, round by adding 1, and store bits [16:1] to "dst".
        ///
        ///__m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b)
        ///VPMULHRSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mulhrs_epi16", Category)]
        public object mm256_mulhrs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyHighRoundScale);
        
        /// <summary>
        /// Multiply the packed 16-bit integers in "a" and "b", producing intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in "dst".
        ///
        ///__m256i _mm256_mullo_epi16 (__m256i a, __m256i b)
        ///VPMULLW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mullo_epi16", Category)]
        public object mm256_mullo_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyLow);
        
        /// <summary>
        /// Multiply the packed 32-bit integers in "a" and "b", producing intermediate 64-bit integers, and store the low 32 bits of the intermediate integers in "dst".
        ///
        ///__m256i _mm256_mullo_epi32 (__m256i a, __m256i b)
        ///VPMULLD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_mullo_epi32", Category)]
        public object mm256_mullo_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.MultiplyLow);
        
        /// <summary>
        /// Compute the bitwise OR of 256 bits (representing integer data) in "a" and "b", and store the result in "dst".
        ///
        ///__m256i _mm256_or_si256 (__m256i a, __m256i b)
        ///VPOR ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_or_si256", Category)]
        public object mm256_or_si256(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Or);
        
        /// <summary>
        /// Convert packed 16-bit integers from "a" and "b" to packed 8-bit integers using signed saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_packs_epi16 (__m256i a, __m256i b)
        ///VPACKSSWB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_packs_epi16", Category)]
        public object mm256_packs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.PackSignedSaturate);
        
        /// <summary>
        /// Convert packed 32-bit integers from "a" and "b" to packed 16-bit integers using signed saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_packs_epi32 (__m256i a, __m256i b)
        ///VPACKSSDW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_packs_epi32", Category)]
        public object mm256_packs_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.PackSignedSaturate);
        
        /// <summary>
        /// Convert packed 16-bit integers from "a" and "b" to packed 8-bit integers using unsigned saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_packus_epi16 (__m256i a, __m256i b)
        ///VPACKUSWB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_packus_epi16", Category)]
        public object mm256_packus_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.PackUnsignedSaturate);
        
        /// <summary>
        /// Convert packed 32-bit integers from "a" and "b" to packed 16-bit integers using unsigned saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_packus_epi32 (__m256i a, __m256i b)
        ///VPACKUSDW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_packus_epi32", Category)]
        public object mm256_packus_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.PackUnsignedSaturate);
        
        /// <summary>
        /// Shuffle 128-bits (composed of integer data) selected by "imm8" from "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
        ///VPERM2I128 ymm, ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute2x128_si256", Category)]
        public object mm256_permute2x128_si256(object a, object b, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, imm8, System.Runtime.Intrinsics.X86.Avx2.Permute2x128);
        
        /// <summary>
        /// Shuffle 64-bit integers in "a" across lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
        ///VPERMQ ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute4x64_epi64", Category)]
        public object mm256_permute4x64_epi64(object a, byte imm8) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.Permute4x64);
        
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements in "a" across lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256d _mm256_permute4x64_pd (__m256d a, const int imm8)
        ///VPERMPD ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_permute4x64_pd", Category)]
        public object mm256_permute4x64_pd(object a, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector256<double>, byte, byte, double, System.Runtime.Intrinsics.Vector256<double>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.Permute4x64);
        
        /// <summary>
        /// Shuffle 32-bit integers in "a" across lanes using the corresponding index in "idx", and store the results in "dst".
        ///
        ///__m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
        ///VPERMD ymm, ymm/m256, ymm
        /// <param name="a"></param>
        /// <param name="idx"></param>
        /// </summary>
        [KalkExport("mm256_permutevar8x32_epi32", Category)]
        public object mm256_permutevar8x32_epi32(object a, object idx) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, idx, System.Runtime.Intrinsics.X86.Avx2.PermuteVar8x32);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" across lanes using the corresponding index in "idx".
        ///
        ///__m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx)
        ///VPERMPS ymm, ymm/m256, ymm
        /// <param name="a"></param>
        /// <param name="idx"></param>
        /// </summary>
        [KalkExport("mm256_permutevar8x32_ps", Category)]
        public object mm256_permutevar8x32_ps(object a, object idx) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector256<float>, int, System.Runtime.Intrinsics.Vector256<int>, float, System.Runtime.Intrinsics.Vector256<float>>(a, idx, System.Runtime.Intrinsics.X86.Avx2.PermuteVar8x32);
        
        /// <summary>
        /// Compute the absolute differences of packed unsigned 8-bit integers in "a" and "b", then horizontally sum each consecutive 8 differences to produce four unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low 16 bits of 64-bit elements in "dst".
        ///
        ///__m256i _mm256_sad_epu8 (__m256i a, __m256i b)
        ///VPSADBW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sad_epu8", Category)]
        public object mm256_sad_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.SumAbsoluteDifferences);
        
        /// <summary>
        /// Shuffle 32-bit integers in "a" within 128-bit lanes using the control in "imm8", and store the results in "dst".
        ///
        ///__m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
        ///VPSHUFD ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_shuffle_epi32", Category)]
        public object mm256_shuffle_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.Shuffle);
        
        /// <summary>
        /// Shuffle 8-bit integers in "a" within 128-bit lanes according to shuffle control mask in the corresponding 8-bit element of "b", and store the results in "dst".
        ///
        ///__m256i _mm256_shuffle_epi8 (__m256i a, __m256i b)
        ///VPSHUFB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_shuffle_epi8", Category)]
        public object mm256_shuffle_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Shuffle);
        
        /// <summary>
        /// Shuffle 16-bit integers in the high 64 bits of 128-bit lanes of "a" using the control in "imm8". Store the results in the high 64 bits of 128-bit lanes of "dst", with the low 64 bits of 128-bit lanes being copied from from "a" to "dst".
        ///
        ///__m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
        ///VPSHUFHW ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_shufflehi_epi16", Category)]
        public object mm256_shufflehi_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, byte, byte, short, System.Runtime.Intrinsics.Vector256<short>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShuffleHigh);
        
        /// <summary>
        /// Shuffle 16-bit integers in the low 64 bits of 128-bit lanes of "a" using the control in "imm8". Store the results in the low 64 bits of 128-bit lanes of "dst", with the high 64 bits of 128-bit lanes being copied from from "a" to "dst".
        ///
        ///__m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
        ///VPSHUFLW ymm, ymm/m256, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_shufflelo_epi16", Category)]
        public object mm256_shufflelo_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, byte, byte, short, System.Runtime.Intrinsics.Vector256<short>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShuffleLow);
        
        /// <summary>
        /// Negate packed 16-bit integers in "a" when the corresponding signed 16-bit integer in "b" is negative, and store the results in "dst". Element in "dst" are zeroed out when the corresponding element in "b" is zero.
        ///
        ///__m256i _mm256_sign_epi16 (__m256i a, __m256i b)
        ///VPSIGNW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sign_epi16", Category)]
        public object mm256_sign_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Sign);
        
        /// <summary>
        /// Negate packed 32-bit integers in "a" when the corresponding signed 32-bit integer in "b" is negative, and store the results in "dst". Element in "dst" are zeroed out when the corresponding element in "b" is zero.
        ///
        ///__m256i _mm256_sign_epi32 (__m256i a, __m256i b)
        ///VPSIGND ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sign_epi32", Category)]
        public object mm256_sign_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Sign);
        
        /// <summary>
        /// Negate packed 8-bit integers in "a" when the corresponding signed 8-bit integer in "b" is negative, and store the results in "dst". Element in "dst" are zeroed out when the corresponding element in "b" is zero.
        ///
        ///__m256i _mm256_sign_epi8 (__m256i a, __m256i b)
        ///VPSIGNB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sign_epi8", Category)]
        public object mm256_sign_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Sign);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" left by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_sll_epi16 (__m256i a, __m128i count)
        ///VPSLLW ymm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_sll_epi16", Category)]
        public object mm256_sll_epi16(object a, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" left by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_sll_epi32 (__m256i a, __m128i count)
        ///VPSLLD ymm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_sll_epi32", Category)]
        public object mm256_sll_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" left by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_sll_epi64 (__m256i a, __m128i count)
        ///VPSLLQ ymm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_sll_epi64", Category)]
        public object mm256_sll_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" left by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_slli_epi16 (__m256i a, int imm8)
        ///VPSLLW ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_slli_epi16", Category)]
        public object mm256_slli_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, byte, byte, short, System.Runtime.Intrinsics.Vector256<short>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" left by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_slli_epi32 (__m256i a, int imm8)
        ///VPSLLD ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_slli_epi32", Category)]
        public object mm256_slli_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" left by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_slli_epi64 (__m256i a, int imm8)
        ///VPSLLQ ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_slli_epi64", Category)]
        public object mm256_slli_epi64(object a, byte imm8) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" left by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
        ///VPSLLVD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_sllv_epi32", Category)]
        public object mm256_sllv_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, uint, System.Runtime.Intrinsics.Vector256<uint>, int, System.Runtime.Intrinsics.Vector256<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogicalVariable);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" left by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_sllv_epi64 (__m256i a, __m256i count)
        ///VPSLLVQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_sllv_epi64", Category)]
        public object mm256_sllv_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, ulong, System.Runtime.Intrinsics.Vector256<ulong>, long, System.Runtime.Intrinsics.Vector256<long>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftLeftLogicalVariable);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "imm8" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m256i _mm256_srai_epi16 (__m256i a, int imm8)
        ///VPSRAW ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_srai_epi16", Category)]
        public object mm256_srai_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, byte, byte, short, System.Runtime.Intrinsics.Vector256<short>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftRightArithmetic);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "imm8" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m256i _mm256_srai_epi32 (__m256i a, int imm8)
        ///VPSRAD ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_srai_epi32", Category)]
        public object mm256_srai_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftRightArithmetic);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by the amount specified by the corresponding element in "count" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m256i _mm256_srav_epi32 (__m256i a, __m256i count)
        ///VPSRAVD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_srav_epi32", Category)]
        public object mm256_srav_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, uint, System.Runtime.Intrinsics.Vector256<uint>, int, System.Runtime.Intrinsics.Vector256<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightArithmeticVariable);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srl_epi16 (__m256i a, __m128i count)
        ///VPSRLW ymm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_srl_epi16", Category)]
        public object mm256_srl_epi16(object a, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srl_epi32 (__m256i a, __m128i count)
        ///VPSRLD ymm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_srl_epi32", Category)]
        public object mm256_srl_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" right by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srl_epi64 (__m256i a, __m128i count)
        ///VPSRLQ ymm, ymm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_srl_epi64", Category)]
        public object mm256_srl_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srli_epi16 (__m256i a, int imm8)
        ///VPSRLW ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_srli_epi16", Category)]
        public object mm256_srli_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, byte, byte, short, System.Runtime.Intrinsics.Vector256<short>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srli_epi32 (__m256i a, int imm8)
        ///VPSRLD ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_srli_epi32", Category)]
        public object mm256_srli_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, byte, byte, int, System.Runtime.Intrinsics.Vector256<int>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" right by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srli_epi64 (__m256i a, int imm8)
        ///VPSRLQ ymm, ymm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm256_srli_epi64", Category)]
        public object mm256_srli_epi64(object a, byte imm8) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, byte, byte, long, System.Runtime.Intrinsics.Vector256<long>>(a, imm8, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
        ///VPSRLVD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_srlv_epi32", Category)]
        public object mm256_srlv_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, uint, System.Runtime.Intrinsics.Vector256<uint>, int, System.Runtime.Intrinsics.Vector256<int>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogicalVariable);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" right by the amount specified by the corresponding element in "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m256i _mm256_srlv_epi64 (__m256i a, __m256i count)
        ///VPSRLVQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm256_srlv_epi64", Category)]
        public object mm256_srlv_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, ulong, System.Runtime.Intrinsics.Vector256<ulong>, long, System.Runtime.Intrinsics.Vector256<long>>(a, count, System.Runtime.Intrinsics.X86.Avx2.ShiftRightLogicalVariable);
        
        /// <summary>
        /// Load 256-bits of integer data from memory into "dst" using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 32-byte boundary or a general-protection exception may be generated.
        ///
        ///__m256i _mm256_stream_load_si256 (__m256i const* mem_addr)
        ///VMOVNTDQA ymm, m256
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm256_stream_load_si256", Category)]
        public object mm256_stream_load_si256(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector256<byte>>(mem_addr, 32, Avx2_LoadAlignedVector256NonTemporal989);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>> Avx2_LoadAlignedVector256NonTemporal989 = new Func<IntPtr, System.Runtime.Intrinsics.Vector256<byte>>((arg0) => System.Runtime.Intrinsics.X86.Avx2.LoadAlignedVector256NonTemporal((byte*)arg0));
        /// <summary>
        /// Subtract packed 16-bit integers in "b" from packed 16-bit integers in "a", and store the results in "dst".
        ///
        ///__m256i _mm256_sub_epi16 (__m256i a, __m256i b)
        ///VPSUBW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sub_epi16", Category)]
        public object mm256_sub_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Subtract);
        
        /// <summary>
        /// Subtract packed 32-bit integers in "b" from packed 32-bit integers in "a", and store the results in "dst".
        ///
        ///__m256i _mm256_sub_epi32 (__m256i a, __m256i b)
        ///VPSUBD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sub_epi32", Category)]
        public object mm256_sub_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Subtract);
        
        /// <summary>
        /// Subtract packed 64-bit integers in "b" from packed 64-bit integers in "a", and store the results in "dst".
        ///
        ///__m256i _mm256_sub_epi64 (__m256i a, __m256i b)
        ///VPSUBQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sub_epi64", Category)]
        public object mm256_sub_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Subtract);
        
        /// <summary>
        /// Subtract packed 8-bit integers in "b" from packed 8-bit integers in "a", and store the results in "dst".
        ///
        ///__m256i _mm256_sub_epi8 (__m256i a, __m256i b)
        ///VPSUBB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_sub_epi8", Category)]
        public object mm256_sub_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Subtract);
        
        /// <summary>
        /// Subtract packed 16-bit integers in "b" from packed 16-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_subs_epi16 (__m256i a, __m256i b)
        ///VPSUBSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_subs_epi16", Category)]
        public object mm256_subs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.SubtractSaturate);
        
        /// <summary>
        /// Subtract packed 8-bit integers in "b" from packed 8-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_subs_epi8 (__m256i a, __m256i b)
        ///VPSUBSB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_subs_epi8", Category)]
        public object mm256_subs_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>, sbyte, System.Runtime.Intrinsics.Vector256<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.SubtractSaturate);
        
        /// <summary>
        /// Subtract packed unsigned 16-bit integers in "b" from packed unsigned 16-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_subs_epu16 (__m256i a, __m256i b)
        ///VPSUBUSW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_subs_epu16", Category)]
        public object mm256_subs_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>, ushort, System.Runtime.Intrinsics.Vector256<ushort>>(a, b, System.Runtime.Intrinsics.X86.Avx2.SubtractSaturate);
        
        /// <summary>
        /// Subtract packed unsigned 8-bit integers in "b" from packed unsigned 8-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m256i _mm256_subs_epu8 (__m256i a, __m256i b)
        ///VPSUBUSB ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_subs_epu8", Category)]
        public object mm256_subs_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.SubtractSaturate);
        
        /// <summary>
        /// Unpack and interleave 16-bit integers from the high half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b)
        ///VPUNPCKHWD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpackhi_epi16", Category)]
        public object mm256_unpackhi_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 32-bit integers from the high half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b)
        ///VPUNPCKHDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpackhi_epi32", Category)]
        public object mm256_unpackhi_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 64-bit integers from the high half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b)
        ///VPUNPCKHQDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpackhi_epi64", Category)]
        public object mm256_unpackhi_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 8-bit integers from the high half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b)
        ///VPUNPCKHBW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpackhi_epi8", Category)]
        public object mm256_unpackhi_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 16-bit integers from the low half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b)
        ///VPUNPCKLWD ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpacklo_epi16", Category)]
        public object mm256_unpacklo_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>, short, System.Runtime.Intrinsics.Vector256<short>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave 32-bit integers from the low half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b)
        ///VPUNPCKLDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpacklo_epi32", Category)]
        public object mm256_unpacklo_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>, int, System.Runtime.Intrinsics.Vector256<int>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave 64-bit integers from the low half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b)
        ///VPUNPCKLQDQ ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpacklo_epi64", Category)]
        public object mm256_unpacklo_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>, long, System.Runtime.Intrinsics.Vector256<long>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave 8-bit integers from the low half of each 128-bit lane in "a" and "b", and store the results in "dst".
        ///
        ///__m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b)
        ///VPUNPCKLBW ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_unpacklo_epi8", Category)]
        public object mm256_unpacklo_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.UnpackLow);
        
        /// <summary>
        /// Compute the bitwise XOR of 256 bits (representing integer data) in "a" and "b", and store the result in "dst".
        ///
        ///__m256i _mm256_xor_si256 (__m256i a, __m256i b)
        ///VPXOR ymm, ymm, ymm/m256
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm256_xor_si256", Category)]
        public object mm256_xor_si256(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>, byte, System.Runtime.Intrinsics.Vector256<byte>>(a, b, System.Runtime.Intrinsics.X86.Avx2.Xor);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Bmi1IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / BMI1";

        /// <summary>
        /// unsigned int _andn_u32 (unsigned int a, unsigned int b)
        ///ANDN r32a, r32b, reg/m32
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("andn_u32", Category)]
        public uint andn_u32(uint left, uint right) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(left, right, System.Runtime.Intrinsics.X86.Bmi1.AndNot);
        
        /// <summary>
        /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len)
        ///BEXTR r32a, reg/m32, r32b
        /// <param name="value"></param>
        /// <param name="start"></param>
        /// <param name="length"></param>
        /// </summary>
        [KalkExport("bextr_u32", Category)]
        public uint bextr_u32(uint value, byte start, byte length) => (uint)ProcessFunc<uint, uint, byte, byte, byte, byte, uint, uint>(value, start, length, System.Runtime.Intrinsics.X86.Bmi1.BitFieldExtract);
        
        /// <summary>
        /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control)
        ///BEXTR r32a, reg/m32, r32b
        /// <param name="value"></param>
        /// <param name="control"></param>
        /// </summary>
        [KalkExport("bextr2_u32", Category)]
        public uint bextr2_u32(uint value, ushort control) => (uint)ProcessFunc<uint, uint, ushort, ushort, uint, uint>(value, control, System.Runtime.Intrinsics.X86.Bmi1.BitFieldExtract);
        
        /// <summary>
        /// unsigned int _blsi_u32 (unsigned int a)
        ///BLSI reg, reg/m32
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("blsi_u32", Category)]
        public uint blsi_u32(uint value) => (uint)ProcessFunc<uint, uint, uint, uint>(value, System.Runtime.Intrinsics.X86.Bmi1.ExtractLowestSetBit);
        
        /// <summary>
        /// unsigned int _blsmsk_u32 (unsigned int a)
        ///BLSMSK reg, reg/m32
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("blsmsk_u32", Category)]
        public uint blsmsk_u32(uint value) => (uint)ProcessFunc<uint, uint, uint, uint>(value, System.Runtime.Intrinsics.X86.Bmi1.GetMaskUpToLowestSetBit);
        
        /// <summary>
        /// unsigned int _blsr_u32 (unsigned int a)
        ///BLSR reg, reg/m32
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("blsr_u32", Category)]
        public uint blsr_u32(uint value) => (uint)ProcessFunc<uint, uint, uint, uint>(value, System.Runtime.Intrinsics.X86.Bmi1.ResetLowestSetBit);
        
        /// <summary>
        /// int _mm_tzcnt_32 (unsigned int a)
        ///TZCNT reg, reg/m32
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("mm_tzcnt_32", Category)]
        public uint mm_tzcnt_32(uint value) => (uint)ProcessFunc<uint, uint, uint, uint>(value, System.Runtime.Intrinsics.X86.Bmi1.TrailingZeroCount);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Bmi1X64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / BMI1";

        /// <summary>
        /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b)
        ///ANDN r64a, r64b, reg/m64
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("andn_u64", Category)]
        public ulong andn_u64(ulong left, ulong right) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong, ulong, ulong>(left, right, System.Runtime.Intrinsics.X86.Bmi1.X64.AndNot);
        
        /// <summary>
        /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len)
        ///BEXTR r64a, reg/m64, r64b
        /// <param name="value"></param>
        /// <param name="start"></param>
        /// <param name="length"></param>
        /// </summary>
        [KalkExport("bextr_u64", Category)]
        public ulong bextr_u64(ulong value, byte start, byte length) => (ulong)ProcessFunc<ulong, ulong, byte, byte, byte, byte, ulong, ulong>(value, start, length, System.Runtime.Intrinsics.X86.Bmi1.X64.BitFieldExtract);
        
        /// <summary>
        /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control)
        ///BEXTR r64a, reg/m64, r64b
        /// <param name="value"></param>
        /// <param name="control"></param>
        /// </summary>
        [KalkExport("bextr2_u64", Category)]
        public ulong bextr2_u64(ulong value, ushort control) => (ulong)ProcessFunc<ulong, ulong, ushort, ushort, ulong, ulong>(value, control, System.Runtime.Intrinsics.X86.Bmi1.X64.BitFieldExtract);
        
        /// <summary>
        /// unsigned __int64 _blsi_u64 (unsigned __int64 a)
        ///BLSI reg, reg/m64
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("blsi_u64", Category)]
        public ulong blsi_u64(ulong value) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong>(value, System.Runtime.Intrinsics.X86.Bmi1.X64.ExtractLowestSetBit);
        
        /// <summary>
        /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a)
        ///BLSMSK reg, reg/m64
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("blsmsk_u64", Category)]
        public ulong blsmsk_u64(ulong value) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong>(value, System.Runtime.Intrinsics.X86.Bmi1.X64.GetMaskUpToLowestSetBit);
        
        /// <summary>
        /// unsigned __int64 _blsr_u64 (unsigned __int64 a)
        ///BLSR reg, reg/m64
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("blsr_u64", Category)]
        public ulong blsr_u64(ulong value) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong>(value, System.Runtime.Intrinsics.X86.Bmi1.X64.ResetLowestSetBit);
        
        /// <summary>
        /// __int64 _mm_tzcnt_64 (unsigned __int64 a)
        ///TZCNT reg, reg/m64
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("mm_tzcnt_64", Category)]
        public ulong mm_tzcnt_64(ulong value) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong>(value, System.Runtime.Intrinsics.X86.Bmi1.X64.TrailingZeroCount);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Bmi2IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / BMI2";

        /// <summary>
        /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index)
        ///BZHI r32a, reg/m32, r32b
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("bzhi_u32", Category)]
        public uint bzhi_u32(uint value, uint index) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(value, index, System.Runtime.Intrinsics.X86.Bmi2.ZeroHighBits);
        
        /// <summary>
        /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi)
        ///MULX r32a, r32b, reg/m32
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mulx_u32", Category)]
        public uint mulx_u32(uint left, uint right) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(left, right, System.Runtime.Intrinsics.X86.Bmi2.MultiplyNoFlags);
        
        /// <summary>
        /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask)
        ///PDEP r32a, r32b, reg/m32
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("pdep_u32", Category)]
        public uint pdep_u32(uint value, uint mask) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(value, mask, System.Runtime.Intrinsics.X86.Bmi2.ParallelBitDeposit);
        
        /// <summary>
        /// unsigned int _pext_u32 (unsigned int a, unsigned int mask)
        ///PEXT r32a, r32b, reg/m32
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("pext_u32", Category)]
        public uint pext_u32(uint value, uint mask) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(value, mask, System.Runtime.Intrinsics.X86.Bmi2.ParallelBitExtract);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Bmi2X64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / BMI2";

        /// <summary>
        /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index)
        ///BZHI r64a, reg/m32, r64b
        /// <param name="value"></param>
        /// <param name="index"></param>
        /// </summary>
        [KalkExport("bzhi_u64", Category)]
        public ulong bzhi_u64(ulong value, ulong index) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong, ulong, ulong>(value, index, System.Runtime.Intrinsics.X86.Bmi2.X64.ZeroHighBits);
        
        /// <summary>
        /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi)
        ///MULX r64a, r64b, reg/m64
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// </summary>
        [KalkExport("mulx_u64", Category)]
        public ulong mulx_u64(ulong left, ulong right) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong, ulong, ulong>(left, right, System.Runtime.Intrinsics.X86.Bmi2.X64.MultiplyNoFlags);
        
        /// <summary>
        /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask)
        ///PDEP r64a, r64b, reg/m64
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("pdep_u64", Category)]
        public ulong pdep_u64(ulong value, ulong mask) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong, ulong, ulong>(value, mask, System.Runtime.Intrinsics.X86.Bmi2.X64.ParallelBitDeposit);
        
        /// <summary>
        /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask)
        ///PEXT r64a, r64b, reg/m64
        /// <param name="value"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("pext_u64", Category)]
        public ulong pext_u64(ulong value, ulong mask) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong, ulong, ulong>(value, mask, System.Runtime.Intrinsics.X86.Bmi2.X64.ParallelBitExtract);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class SseIntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE";

        /// <summary>
        /// Add packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_add_ps (__m128 a,  __m128 b)
        ///ADDPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_ps", Category)]
        public object mm_add_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Add);
        
        /// <summary>
        /// Add the lower single-precision (32-bit) floating-point element in "a" and "b", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_add_ss (__m128 a,  __m128 b)
        ///ADDSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_ss", Category)]
        public object mm_add_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.AddScalar);
        
        /// <summary>
        /// Compute the bitwise AND of packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_and_ps (__m128 a, __m128 b)
        ///ANDPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_and_ps", Category)]
        public object mm_and_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.And);
        
        /// <summary>
        /// Compute the bitwise NOT of packed single-precision (32-bit) floating-point elements in "a" and then AND with "b", and store the results in "dst".
        ///
        ///__m128 _mm_andnot_ps (__m128 a, __m128 b)
        ///ANDNPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_andnot_ps", Category)]
        public object mm_andnot_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.AndNot);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m128 _mm_cmpeq_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(0)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_ps", Category)]
        public object mm_cmpeq_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for equality, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpeq_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(0)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_ss", Category)]
        public object mm_cmpeq_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarEqual);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for greater-than-or-equal, and store the results in "dst".
        ///
        ///__m128 _mm_cmpge_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpge_ps", Category)]
        public object mm_cmpge_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for greater-than-or-equal, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpge_ss (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m32, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpge_ss", Category)]
        public object mm_cmpge_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarGreaterThanOrEqual);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m128 _mm_cmpgt_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_ps", Category)]
        public object mm_cmpgt_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareGreaterThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for greater-than, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpgt_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_ss", Category)]
        public object mm_cmpgt_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarGreaterThan);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for less-than-or-equal, and store the results in "dst".
        ///
        ///__m128 _mm_cmple_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmple_ps", Category)]
        public object mm_cmple_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for less-than-or-equal, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmple_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmple_ss", Category)]
        public object mm_cmple_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarLessThanOrEqual);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for less-than, and store the results in "dst".
        ///
        ///__m128 _mm_cmplt_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_ps", Category)]
        public object mm_cmplt_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareLessThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for less-than, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmplt_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_ss", Category)]
        public object mm_cmplt_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarLessThan);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for not-equal, and store the results in "dst".
        ///
        ///__m128 _mm_cmpneq_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpneq_ps", Category)]
        public object mm_cmpneq_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareNotEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for not-equal, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpneq_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(4)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpneq_ss", Category)]
        public object mm_cmpneq_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarNotEqual);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for not-greater-than-or-equal, and store the results in "dst".
        ///
        ///__m128 _mm_cmpnge_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnge_ps", Category)]
        public object mm_cmpnge_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareNotGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for not-greater-than-or-equal, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpnge_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnge_ss", Category)]
        public object mm_cmpnge_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarNotGreaterThanOrEqual);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for not-greater-than, and store the results in "dst".
        ///
        ///__m128 _mm_cmpngt_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpngt_ps", Category)]
        public object mm_cmpngt_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareNotGreaterThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for not-greater-than, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpngt_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpngt_ss", Category)]
        public object mm_cmpngt_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarNotGreaterThan);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for not-less-than-or-equal, and store the results in "dst".
        ///
        ///__m128 _mm_cmpnle_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnle_ps", Category)]
        public object mm_cmpnle_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareNotLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for not-less-than-or-equal, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpnle_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnle_ss", Category)]
        public object mm_cmpnle_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarNotLessThanOrEqual);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" for not-less-than, and store the results in "dst".
        ///
        ///__m128 _mm_cmpnlt_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnlt_ps", Category)]
        public object mm_cmpnlt_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareNotLessThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" for not-less-than, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpnlt_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnlt_ss", Category)]
        public object mm_cmpnlt_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarNotLessThan);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" to see if neither is NaN, and store the results in "dst".
        ///
        ///__m128 _mm_cmpord_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(7)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpord_ps", Category)]
        public object mm_cmpord_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareOrdered);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" to see if neither is NaN, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpord_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(7)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpord_ss", Category)]
        public object mm_cmpord_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrdered);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b" to see if either is NaN, and store the results in "dst".
        ///
        ///__m128 _mm_cmpunord_ps (__m128 a,  __m128 b)
        ///CMPPS xmm, xmm/m128, imm8(3)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpunord_ps", Category)]
        public object mm_cmpunord_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareUnordered);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b" to see if either is NaN, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cmpunord_ss (__m128 a,  __m128 b)
        ///CMPSS xmm, xmm/m32, imm8(3)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpunord_ss", Category)]
        public object mm_cmpunord_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnordered);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for equality, and return the boolean result (0 or 1).
        ///
        ///int _mm_comieq_ss (__m128 a, __m128 b)
        ///COMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comieq_ss", Category)]
        public KalkBool mm_comieq_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrderedEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for greater-than-or-equal, and return the boolean result (0 or 1).
        ///
        ///int _mm_comige_ss (__m128 a, __m128 b)
        ///COMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comige_ss", Category)]
        public KalkBool mm_comige_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrderedGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for greater-than, and return the boolean result (0 or 1).
        ///
        ///int _mm_comigt_ss (__m128 a, __m128 b)
        ///COMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comigt_ss", Category)]
        public KalkBool mm_comigt_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrderedGreaterThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for less-than-or-equal, and return the boolean result (0 or 1).
        ///
        ///int _mm_comile_ss (__m128 a, __m128 b)
        ///COMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comile_ss", Category)]
        public KalkBool mm_comile_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrderedLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for less-than, and return the boolean result (0 or 1).
        ///
        ///int _mm_comilt_ss (__m128 a, __m128 b)
        ///COMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comilt_ss", Category)]
        public KalkBool mm_comilt_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrderedLessThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for not-equal, and return the boolean result (0 or 1).
        ///
        ///int _mm_comineq_ss (__m128 a, __m128 b)
        ///COMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comineq_ss", Category)]
        public KalkBool mm_comineq_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarOrderedNotEqual);
        
        /// <summary>
        /// Convert the 32-bit integer "b" to a single-precision (32-bit) floating-point element, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cvtsi32_ss (__m128 a, int b)
        ///CVTSI2SS xmm, reg/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cvtsi32_ss", Category)]
        public object mm_cvtsi32_ss(object a, int b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, int, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.ConvertScalarToVector128Single);
        
        /// <summary>
        /// Convert the lower single-precision (32-bit) floating-point element in "a" to a 32-bit integer, and store the result in "dst".
        ///
        ///int _mm_cvtss_si32 (__m128 a)
        ///CVTSS2SI r32, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtss_si32", Category)]
        public int mm_cvtss_si32(object a) => (int)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, int>(a, System.Runtime.Intrinsics.X86.Sse.ConvertToInt32);
        
        /// <summary>
        /// Convert the lower single-precision (32-bit) floating-point element in "a" to a 32-bit integer with truncation, and store the result in "dst".
        ///
        ///int _mm_cvttss_si32 (__m128 a)
        ///CVTTSS2SI r32, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvttss_si32", Category)]
        public int mm_cvttss_si32(object a) => (int)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, int>(a, System.Runtime.Intrinsics.X86.Sse.ConvertToInt32WithTruncation);
        
        /// <summary>
        /// Divide packed single-precision (32-bit) floating-point elements in "a" by packed elements in "b", and store the results in "dst".
        ///
        ///__m128 _mm_div_ps (__m128 a,  __m128 b)
        ///DIVPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_div_ps", Category)]
        public object mm_div_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Divide);
        
        /// <summary>
        /// Divide the lower single-precision (32-bit) floating-point element in "a" by the lower single-precision (32-bit) floating-point element in "b", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_div_ss (__m128 a,  __m128 b)
        ///DIVSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_div_ss", Category)]
        public object mm_div_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.DivideScalar);
        
        /// <summary>
        /// Load 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///__m128 _mm_load_ps (float const* mem_address)
        ///MOVAPS xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_load_ps", Category)]
        public object mm_load_ps(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, 16, Sse_LoadAlignedVector12848);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_LoadAlignedVector12848 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0) => System.Runtime.Intrinsics.X86.Sse.LoadAlignedVector128((float*)arg0));
        /// <summary>
        /// Load a single-precision (32-bit) floating-point element from memory into the lower of "dst", and zero the upper 3 elements. "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128 _mm_load_ss (float const* mem_address)
        ///MOVSS xmm, m32
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_load_ss", Category)]
        public object mm_load_ss(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, Sse_LoadScalarVector12851);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_LoadScalarVector12851 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0) => System.Runtime.Intrinsics.X86.Sse.LoadScalarVector128((float*)arg0));
        /// <summary>
        /// Load 2 single-precision (32-bit) floating-point elements from memory into the upper 2 elements of "dst", and copy the lower 2 elements from "a" to "dst". "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128 _mm_loadh_pi (__m128 a, __m64 const* mem_addr)
        ///MOVHPS xmm, m64
        /// <param name="a"></param>
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadh_pi", Category)]
        public object mm_loadh_pi(object a, object mem_addr) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(a, mem_addr, Sse_LoadHigh49);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_LoadHigh49 = new Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.LoadHigh((System.Runtime.Intrinsics.Vector128<float>)arg0, (float*)arg1));
        /// <summary>
        /// Load 2 single-precision (32-bit) floating-point elements from memory into the lower 2 elements of "dst", and copy the upper 2 elements from "a" to "dst". "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128 _mm_loadl_pi (__m128 a, __m64 const* mem_addr)
        ///MOVLPS xmm, m64
        /// <param name="a"></param>
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadl_pi", Category)]
        public object mm_loadl_pi(object a, object mem_addr) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(a, mem_addr, Sse_LoadLow50);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_LoadLow50 = new Func<System.Runtime.Intrinsics.Vector128<float>, IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.LoadLow((System.Runtime.Intrinsics.Vector128<float>)arg0, (float*)arg1));
        /// <summary>
        /// Load 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128 _mm_loadu_ps (float const* mem_address)
        ///MOVUPS xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadu_ps", Category)]
        public object mm_loadu_ps(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, Sse_LoadVector12852);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_LoadVector12852 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0) => System.Runtime.Intrinsics.X86.Sse.LoadVector128((float*)arg0));
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128 _mm_max_ps (__m128 a,  __m128 b)
        ///MAXPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_ps", Category)]
        public object mm_max_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Max);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b", store the maximum value in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128 _mm_max_ss (__m128 a,  __m128 b)
        ///MAXSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_ss", Category)]
        public object mm_max_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.MaxScalar);
        
        /// <summary>
        /// Compare packed single-precision (32-bit) floating-point elements in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128 _mm_min_ps (__m128 a,  __m128 b)
        ///MINPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_ps", Category)]
        public object mm_min_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Min);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point elements in "a" and "b", store the minimum value in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128 _mm_min_ss (__m128 a,  __m128 b)
        ///MINSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_ss", Category)]
        public object mm_min_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.MinScalar);
        
        /// <summary>
        /// Move the lower single-precision (32-bit) floating-point element from "b" to the lower element of "dst", and copy the upper 3 elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_move_ss (__m128 a, __m128 b)
        ///MOVSS xmm, xmm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_move_ss", Category)]
        public object mm_move_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.MoveScalar);
        
        /// <summary>
        /// Move the upper 2 single-precision (32-bit) floating-point elements from "b" to the lower 2 elements of "dst", and copy the upper 2 elements from "a" to the upper 2 elements of "dst".
        ///
        ///__m128 _mm_movehl_ps (__m128 a,  __m128 b)
        ///MOVHLPS xmm, xmm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_movehl_ps", Category)]
        public object mm_movehl_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.MoveHighToLow);
        
        /// <summary>
        /// Move the lower 2 single-precision (32-bit) floating-point elements from "b" to the upper 2 elements of "dst", and copy the lower 2 elements from "a" to the lower 2 elements of "dst".
        ///
        ///__m128 _mm_movelh_ps (__m128 a,  __m128 b)
        ///MOVLHPS xmm, xmm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_movelh_ps", Category)]
        public object mm_movelh_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.MoveLowToHigh);
        
        /// <summary>
        /// Set each bit of mask "dst" based on the most significant bit of the corresponding packed single-precision (32-bit) floating-point element in "a".
        ///
        ///int _mm_movemask_ps (__m128 a)
        ///MOVMSKPS reg, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_movemask_ps", Category)]
        public int mm_movemask_ps(object a) => (int)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, int>(a, System.Runtime.Intrinsics.X86.Sse.MoveMask);
        
        /// <summary>
        /// Multiply packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_mul_ps (__m128 a, __m128 b)
        ///MULPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mul_ps", Category)]
        public object mm_mul_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Multiply);
        
        /// <summary>
        /// Multiply the lower single-precision (32-bit) floating-point element in "a" and "b", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_mul_ss (__m128 a, __m128 b)
        ///MULPS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mul_ss", Category)]
        public object mm_mul_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.MultiplyScalar);
        
        /// <summary>
        /// Compute the bitwise OR of packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_or_ps (__m128 a,  __m128 b)
        ///ORPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_or_ps", Category)]
        public object mm_or_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Or);
        
        /// <summary>
        /// Fetch the line of data from memory that contains address "p" to a location in the cache heirarchy specified by the locality hint "i".
        ///
        ///void _mm_prefetch(char* p, int i)
        ///PREFETCHT0 m8
        /// <param name="p"></param>
        /// </summary>
        [KalkExport("mm_prefetch0", Category)]
        public void mm_prefetch0(object p) => ProcessAction<IntPtr, IntPtr>(p, Sse_Prefetch064);
        private unsafe readonly static Action<IntPtr> Sse_Prefetch064 = new Action<IntPtr>((arg0) => System.Runtime.Intrinsics.X86.Sse.Prefetch0((void*)arg0));
        /// <summary>
        /// Fetch the line of data from memory that contains address "p" to a location in the cache heirarchy specified by the locality hint "i".
        ///
        ///void _mm_prefetch(char* p, int i)
        ///PREFETCHT1 m8
        /// <param name="p"></param>
        /// </summary>
        [KalkExport("mm_prefetch1", Category)]
        public void mm_prefetch1(object p) => ProcessAction<IntPtr, IntPtr>(p, Sse_Prefetch165);
        private unsafe readonly static Action<IntPtr> Sse_Prefetch165 = new Action<IntPtr>((arg0) => System.Runtime.Intrinsics.X86.Sse.Prefetch1((void*)arg0));
        /// <summary>
        /// Fetch the line of data from memory that contains address "p" to a location in the cache heirarchy specified by the locality hint "i".
        ///
        ///void _mm_prefetch(char* p, int i)
        ///PREFETCHT2 m8
        /// <param name="p"></param>
        /// </summary>
        [KalkExport("mm_prefetch2", Category)]
        public void mm_prefetch2(object p) => ProcessAction<IntPtr, IntPtr>(p, Sse_Prefetch266);
        private unsafe readonly static Action<IntPtr> Sse_Prefetch266 = new Action<IntPtr>((arg0) => System.Runtime.Intrinsics.X86.Sse.Prefetch2((void*)arg0));
        /// <summary>
        /// Fetch the line of data from memory that contains address "p" to a location in the cache heirarchy specified by the locality hint "i".
        ///
        ///void _mm_prefetch(char* p, int i)
        ///PREFETCHNTA m8
        /// <param name="p"></param>
        /// </summary>
        [KalkExport("mm_prefetchnta", Category)]
        public void mm_prefetchnta(object p) => ProcessAction<IntPtr, IntPtr>(p, Sse_PrefetchNonTemporal67);
        private unsafe readonly static Action<IntPtr> Sse_PrefetchNonTemporal67 = new Action<IntPtr>((arg0) => System.Runtime.Intrinsics.X86.Sse.PrefetchNonTemporal((void*)arg0));
        /// <summary>
        /// Compute the approximate reciprocal of packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m128 _mm_rcp_ps (__m128 a)
        ///RCPPS xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_rcp_ps", Category)]
        public object mm_rcp_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse.Reciprocal);
        
        /// <summary>
        /// Compute the approximate reciprocal of the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m128 _mm_rcp_ss (__m128 a, __m128 b)
        ///RCPSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("mm_rcp_ss", Category)]
        public object mm_rcp_ss(object a, object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, value, System.Runtime.Intrinsics.X86.Sse.ReciprocalScalar);
        
        /// <summary>
        /// Compute the approximate reciprocal of the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m128 _mm_rcp_ss (__m128 a)
        ///RCPSS xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_rcp_ss1", Category)]
        public object mm_rcp_ss1(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse.ReciprocalScalar);
        
        /// <summary>
        /// Compute the approximate reciprocal square root of packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m128 _mm_rsqrt_ps (__m128 a)
        ///RSQRTPS xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_rsqrt_ps", Category)]
        public object mm_rsqrt_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse.ReciprocalSqrt);
        
        /// <summary>
        /// Compute the approximate reciprocal square root of the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m128 _mm_rsqrt_ss (__m128 a, __m128 b)
        ///RSQRTSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("mm_rsqrt_ss", Category)]
        public object mm_rsqrt_ss(object a, object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, value, System.Runtime.Intrinsics.X86.Sse.ReciprocalSqrtScalar);
        
        /// <summary>
        /// Compute the approximate reciprocal square root of the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst". The maximum relative error for this approximation is less than 1.5*2^-12.
        ///
        ///__m128 _mm_rsqrt_ss (__m128 a)
        ///RSQRTSS xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_rsqrt_ss1", Category)]
        public object mm_rsqrt_ss1(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse.ReciprocalSqrtScalar);
        
        /// <summary>
        /// Shuffle single-precision (32-bit) floating-point elements in "a" using the control in "imm8", and store the results in "dst".
        ///
        ///__m128 _mm_shuffle_ps (__m128 a,  __m128 b, unsigned int control)
        ///SHUFPS xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_shuffle_ps", Category)]
        public object mm_shuffle_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse.Shuffle);
        
        /// <summary>
        /// Compute the square root of packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m128 _mm_sqrt_ps (__m128 a)
        ///SQRTPS xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_sqrt_ps", Category)]
        public object mm_sqrt_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse.Sqrt);
        
        /// <summary>
        /// Compute the square root of the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_sqrt_ss (__m128 a, __m128 b)
        ///SQRTSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="value"></param>
        /// </summary>
        [KalkExport("mm_sqrt_ss", Category)]
        public object mm_sqrt_ss(object a, object value) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, value, System.Runtime.Intrinsics.X86.Sse.SqrtScalar);
        
        /// <summary>
        /// Compute the square root of the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_sqrt_ss (__m128 a)
        ///SQRTSS xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_sqrt_ss1", Category)]
        public object mm_sqrt_ss1(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse.SqrtScalar);
        
        /// <summary>
        /// Store 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm_store_ps (float* mem_addr, __m128 a)
        ///MOVAPS m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_store_ps", Category)]
        public void mm_store_ps(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, 16, a, Sse_StoreAligned79);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_StoreAligned79 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.StoreAligned((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Store the lower single-precision (32-bit) floating-point element from "a" into memory. "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_store_ss (float* mem_addr, __m128 a)
        ///MOVSS m32, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_store_ss", Category)]
        public void mm_store_ss(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, a, Sse_StoreScalar83);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_StoreScalar83 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.StoreScalar((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Store the upper 2 single-precision (32-bit) floating-point elements from "a" into memory.
        ///
        ///void _mm_storeh_pi (__m64* mem_addr, __m128 a)
        ///MOVHPS m64, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storeh_pi", Category)]
        public void mm_storeh_pi(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, a, Sse_StoreHigh81);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_StoreHigh81 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.StoreHigh((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Store the lower 2 single-precision (32-bit) floating-point elements from "a" into memory.
        ///
        ///void _mm_storel_pi (__m64* mem_addr, __m128 a)
        ///MOVLPS m64, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storel_pi", Category)]
        public void mm_storel_pi(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, a, Sse_StoreLow82);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_StoreLow82 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.StoreLow((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Store 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_storeu_ps (float* mem_addr, __m128 a)
        ///MOVUPS m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storeu_ps", Category)]
        public void mm_storeu_ps(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, a, Sse_Store78);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_Store78 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.Store((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Store 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) from "a" into memory using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm_stream_ps (float* mem_addr, __m128 a)
        ///MOVNTPS m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_stream_ps", Category)]
        public void mm_stream_ps(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, float, System.Runtime.Intrinsics.Vector128<float>>(mem_addr, 16, a, Sse_StoreAlignedNonTemporal80);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>> Sse_StoreAlignedNonTemporal80 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<float>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse.StoreAlignedNonTemporal((float*)arg0, (System.Runtime.Intrinsics.Vector128<float>)arg1));
        /// <summary>
        /// Subtract packed single-precision (32-bit) floating-point elements in "b" from packed single-precision (32-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m128d _mm_sub_ps (__m128d a, __m128d b)
        ///SUBPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_ps", Category)]
        public object mm_sub_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Subtract);
        
        /// <summary>
        /// Subtract the lower single-precision (32-bit) floating-point element in "b" from the lower single-precision (32-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_sub_ss (__m128 a, __m128 b)
        ///SUBSS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_ss", Category)]
        public object mm_sub_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.SubtractScalar);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for equality, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomieq_ss (__m128 a, __m128 b)
        ///UCOMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomieq_ss", Category)]
        public KalkBool mm_ucomieq_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnorderedEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for greater-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomige_ss (__m128 a, __m128 b)
        ///UCOMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomige_ss", Category)]
        public KalkBool mm_ucomige_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnorderedGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for greater-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomigt_ss (__m128 a, __m128 b)
        ///UCOMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomigt_ss", Category)]
        public KalkBool mm_ucomigt_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnorderedGreaterThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for less-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomile_ss (__m128 a, __m128 b)
        ///UCOMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomile_ss", Category)]
        public KalkBool mm_ucomile_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnorderedLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for less-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomilt_ss (__m128 a, __m128 b)
        ///UCOMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomilt_ss", Category)]
        public KalkBool mm_ucomilt_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnorderedLessThan);
        
        /// <summary>
        /// Compare the lower single-precision (32-bit) floating-point element in "a" and "b" for not-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomineq_ss (__m128 a, __m128 b)
        ///UCOMISS xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomineq_ss", Category)]
        public KalkBool mm_ucomineq_ss(object a, object b) => (KalkBool)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse.CompareScalarUnorderedNotEqual);
        
        /// <summary>
        /// Unpack and interleave single-precision (32-bit) floating-point elements from the high half "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_unpackhi_ps (__m128 a,  __m128 b)
        ///UNPCKHPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpackhi_ps", Category)]
        public object mm_unpackhi_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave single-precision (32-bit) floating-point elements from the low half of "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_unpacklo_ps (__m128 a,  __m128 b)
        ///UNPCKLPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpacklo_ps", Category)]
        public object mm_unpacklo_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.UnpackLow);
        
        /// <summary>
        /// Compute the bitwise XOR of packed single-precision (32-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128 _mm_xor_ps (__m128 a,  __m128 b)
        ///XORPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_xor_ps", Category)]
        public object mm_xor_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.Xor);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse2IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE2";

        /// <summary>
        /// Add packed 16-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_add_epi16 (__m128i a,  __m128i b)
        ///PADDW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_epi16", Category)]
        public object mm_add_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Add);
        
        /// <summary>
        /// Add packed 32-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_add_epi32 (__m128i a,  __m128i b)
        ///PADDD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_epi32", Category)]
        public object mm_add_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Add);
        
        /// <summary>
        /// Add packed 64-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_add_epi64 (__m128i a,  __m128i b)
        ///PADDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_epi64", Category)]
        public object mm_add_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Add);
        
        /// <summary>
        /// Add packed 8-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_add_epi8 (__m128i a,  __m128i b)
        ///PADDB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_epi8", Category)]
        public object mm_add_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Add);
        
        /// <summary>
        /// Add packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_add_pd (__m128d a,  __m128d b)
        ///ADDPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_pd", Category)]
        public object mm_add_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Add);
        
        /// <summary>
        /// Add the lower double-precision (64-bit) floating-point element in "a" and "b", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_add_sd (__m128d a,  __m128d b)
        ///ADDSD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_add_sd", Category)]
        public object mm_add_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AddScalar);
        
        /// <summary>
        /// Add packed 16-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_adds_epi16 (__m128i a,  __m128i b)
        ///PADDSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_adds_epi16", Category)]
        public object mm_adds_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AddSaturate);
        
        /// <summary>
        /// Add packed 8-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_adds_epi8 (__m128i a,  __m128i b)
        ///PADDSB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_adds_epi8", Category)]
        public object mm_adds_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AddSaturate);
        
        /// <summary>
        /// Add packed unsigned 16-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_adds_epu16 (__m128i a,  __m128i b)
        ///PADDUSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_adds_epu16", Category)]
        public object mm_adds_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AddSaturate);
        
        /// <summary>
        /// Add packed unsigned 8-bit integers in "a" and "b" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_adds_epu8 (__m128i a,  __m128i b)
        ///PADDUSB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_adds_epu8", Category)]
        public object mm_adds_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AddSaturate);
        
        /// <summary>
        /// Compute the bitwise AND of packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_and_pd (__m128d a, __m128d b)
        ///ANDPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_and_pd", Category)]
        public object mm_and_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.And);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and store the result in "dst".
        ///
        ///__m128i _mm_and_si128 (__m128i a,  __m128i b)
        ///PAND xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_and_si128", Category)]
        public object mm_and_si128(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.And);
        
        /// <summary>
        /// Compute the bitwise NOT of packed double-precision (64-bit) floating-point elements in "a" and then AND with "b", and store the results in "dst".
        ///
        ///__m128d _mm_andnot_pd (__m128d a, __m128d b)
        ///ADDNPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_andnot_pd", Category)]
        public object mm_andnot_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AndNot);
        
        /// <summary>
        /// Compute the bitwise NOT of 128 bits (representing integer data) in "a" and then AND with "b", and store the result in "dst".
        ///
        ///__m128i _mm_andnot_si128 (__m128i a,  __m128i b)
        ///PANDN xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_andnot_si128", Category)]
        public object mm_andnot_si128(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.AndNot);
        
        /// <summary>
        /// Average packed unsigned 16-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_avg_epu16 (__m128i a,  __m128i b)
        ///PAVGW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_avg_epu16", Category)]
        public object mm_avg_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Average);
        
        /// <summary>
        /// Average packed unsigned 8-bit integers in "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_avg_epu8 (__m128i a,  __m128i b)
        ///PAVGB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_avg_epu8", Category)]
        public object mm_avg_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Average);
        
        /// <summary>
        /// Shift "a" left by "imm8" bytes while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_bslli_si128 (__m128i a, int imm8)
        ///PSLLDQ xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_bslli_si128", Category)]
        public object mm_bslli_si128(object a, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical128BitLane);
        
        /// <summary>
        /// Shift "a" right by "imm8" bytes while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_bsrli_si128 (__m128i a, int imm8)
        ///PSRLDQ xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_bsrli_si128", Category)]
        public object mm_bsrli_si128(object a, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical128BitLane);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m128i _mm_cmpeq_epi16 (__m128i a,  __m128i b)
        ///PCMPEQW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_epi16", Category)]
        public object mm_cmpeq_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareEqual);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m128i _mm_cmpeq_epi32 (__m128i a,  __m128i b)
        ///PCMPEQD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_epi32", Category)]
        public object mm_cmpeq_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareEqual);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m128i _mm_cmpeq_epi8 (__m128i a,  __m128i b)
        ///PCMPEQB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_epi8", Category)]
        public object mm_cmpeq_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareEqual);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m128d _mm_cmpeq_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(0)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_pd", Category)]
        public object mm_cmpeq_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for equality, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpeq_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(0)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_sd", Category)]
        public object mm_cmpeq_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarEqual);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for greater-than-or-equal, and store the results in "dst".
        ///
        ///__m128d _mm_cmpge_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpge_pd", Category)]
        public object mm_cmpge_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for greater-than-or-equal, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpge_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpge_sd", Category)]
        public object mm_cmpge_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarGreaterThanOrEqual);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m128i _mm_cmpgt_epi16 (__m128i a,  __m128i b)
        ///PCMPGTW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_epi16", Category)]
        public object mm_cmpgt_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareGreaterThan);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m128i _mm_cmpgt_epi32 (__m128i a,  __m128i b)
        ///PCMPGTD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_epi32", Category)]
        public object mm_cmpgt_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareGreaterThan);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m128i _mm_cmpgt_epi8 (__m128i a,  __m128i b)
        ///PCMPGTB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_epi8", Category)]
        public object mm_cmpgt_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareGreaterThan);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m128d _mm_cmpgt_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_pd", Category)]
        public object mm_cmpgt_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareGreaterThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for greater-than, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpgt_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_sd", Category)]
        public object mm_cmpgt_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarGreaterThan);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for less-than-or-equal, and store the results in "dst".
        ///
        ///__m128d _mm_cmple_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmple_pd", Category)]
        public object mm_cmple_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for less-than-or-equal, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmple_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmple_sd", Category)]
        public object mm_cmple_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarLessThanOrEqual);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b" for less-than, and store the results in "dst". Note: This intrinsic emits the pcmpgtw instruction with the order of the operands switched.
        ///
        ///__m128i _mm_cmplt_epi16 (__m128i a,  __m128i b)
        ///PCMPGTW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_epi16", Category)]
        public object mm_cmplt_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareLessThan);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b" for less-than, and store the results in "dst". Note: This intrinsic emits the pcmpgtd instruction with the order of the operands switched.
        ///
        ///__m128i _mm_cmplt_epi32 (__m128i a,  __m128i b)
        ///PCMPGTD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_epi32", Category)]
        public object mm_cmplt_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareLessThan);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b" for less-than, and store the results in "dst". Note: This intrinsic emits the pcmpgtb instruction with the order of the operands switched.
        ///
        ///__m128i _mm_cmplt_epi8 (__m128i a,  __m128i b)
        ///PCMPGTB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_epi8", Category)]
        public object mm_cmplt_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareLessThan);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for less-than, and store the results in "dst".
        ///
        ///__m128d _mm_cmplt_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_pd", Category)]
        public object mm_cmplt_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareLessThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for less-than, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmplt_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmplt_sd", Category)]
        public object mm_cmplt_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarLessThan);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for not-equal, and store the results in "dst".
        ///
        ///__m128d _mm_cmpneq_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpneq_pd", Category)]
        public object mm_cmpneq_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareNotEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for not-equal, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpneq_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(4)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpneq_sd", Category)]
        public object mm_cmpneq_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarNotEqual);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for not-greater-than-or-equal, and store the results in "dst".
        ///
        ///__m128d _mm_cmpnge_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnge_pd", Category)]
        public object mm_cmpnge_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareNotGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for not-greater-than-or-equal, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpnge_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(1)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnge_sd", Category)]
        public object mm_cmpnge_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarNotGreaterThanOrEqual);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for not-greater-than, and store the results in "dst".
        ///
        ///__m128d _mm_cmpngt_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpngt_pd", Category)]
        public object mm_cmpngt_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareNotGreaterThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for not-greater-than, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpngt_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(2)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpngt_sd", Category)]
        public object mm_cmpngt_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarNotGreaterThan);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for not-less-than-or-equal, and store the results in "dst".
        ///
        ///__m128d _mm_cmpnle_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnle_pd", Category)]
        public object mm_cmpnle_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareNotLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for not-less-than-or-equal, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpnle_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(6)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnle_sd", Category)]
        public object mm_cmpnle_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarNotLessThanOrEqual);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" for not-less-than, and store the results in "dst".
        ///
        ///__m128d _mm_cmpnlt_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnlt_pd", Category)]
        public object mm_cmpnlt_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareNotLessThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" for not-less-than, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpnlt_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(5)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpnlt_sd", Category)]
        public object mm_cmpnlt_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarNotLessThan);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" to see if neither is NaN, and store the results in "dst".
        ///
        ///__m128d _mm_cmpord_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(7)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpord_pd", Category)]
        public object mm_cmpord_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareOrdered);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" to see if neither is NaN, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpord_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(7)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpord_sd", Category)]
        public object mm_cmpord_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrdered);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b" to see if either is NaN, and store the results in "dst".
        ///
        ///__m128d _mm_cmpunord_pd (__m128d a,  __m128d b)
        ///CMPPD xmm, xmm/m128, imm8(3)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpunord_pd", Category)]
        public object mm_cmpunord_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareUnordered);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b" to see if either is NaN, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cmpunord_sd (__m128d a,  __m128d b)
        ///CMPSD xmm, xmm/m64, imm8(3)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpunord_sd", Category)]
        public object mm_cmpunord_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnordered);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for equality, and return the boolean result (0 or 1).
        ///
        ///int _mm_comieq_sd (__m128d a, __m128d b)
        ///COMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comieq_sd", Category)]
        public KalkBool mm_comieq_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrderedEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for greater-than-or-equal, and return the boolean result (0 or 1).
        ///
        ///int _mm_comige_sd (__m128d a, __m128d b)
        ///COMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comige_sd", Category)]
        public KalkBool mm_comige_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrderedGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for greater-than, and return the boolean result (0 or 1).
        ///
        ///int _mm_comigt_sd (__m128d a, __m128d b)
        ///COMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comigt_sd", Category)]
        public KalkBool mm_comigt_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrderedGreaterThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for less-than-or-equal, and return the boolean result (0 or 1).
        ///
        ///int _mm_comile_sd (__m128d a, __m128d b)
        ///COMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comile_sd", Category)]
        public KalkBool mm_comile_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrderedLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for less-than, and return the boolean result (0 or 1).
        ///
        ///int _mm_comilt_sd (__m128d a, __m128d b)
        ///COMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comilt_sd", Category)]
        public KalkBool mm_comilt_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrderedLessThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for not-equal, and return the boolean result (0 or 1).
        ///
        ///int _mm_comineq_sd (__m128d a, __m128d b)
        ///COMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_comineq_sd", Category)]
        public KalkBool mm_comineq_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarOrderedNotEqual);
        
        /// <summary>
        /// Convert packed 32-bit integers in "a" to packed double-precision (64-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m128d _mm_cvtepi32_pd (__m128i a)
        ///CVTDQ2PD xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi32_pd", Category)]
        public object mm_cvtepi32_pd(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Double);
        
        /// <summary>
        /// Convert packed 32-bit integers in "a" to packed single-precision (32-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m128 _mm_cvtepi32_ps (__m128i a)
        ///CVTDQ2PS xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi32_ps", Category)]
        public object mm_cvtepi32_ps(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Single);
        
        /// <summary>
        /// Convert packed double-precision (64-bit) floating-point elements in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtpd_epi32 (__m128d a)
        ///CVTPD2DQ xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtpd_epi32", Category)]
        public object mm_cvtpd_epi32(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Int32);
        
        /// <summary>
        /// Convert packed double-precision (64-bit) floating-point elements in "a" to packed single-precision (32-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m128 _mm_cvtpd_ps (__m128d a)
        ///CVTPD2PS xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtpd_ps", Category)]
        public object mm_cvtpd_ps(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Single);
        
        /// <summary>
        /// Convert packed single-precision (32-bit) floating-point elements in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtps_epi32 (__m128 a)
        ///CVTPS2DQ xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtps_epi32", Category)]
        public object mm_cvtps_epi32(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Int32);
        
        /// <summary>
        /// Convert packed single-precision (32-bit) floating-point elements in "a" to packed double-precision (64-bit) floating-point elements, and store the results in "dst".
        ///
        ///__m128d _mm_cvtps_pd (__m128 a)
        ///CVTPS2PD xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtps_pd", Category)]
        public object mm_cvtps_pd(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Double);
        
        /// <summary>
        /// Convert the lower double-precision (64-bit) floating-point element in "a" to a 32-bit integer, and store the result in "dst".
        ///
        ///int _mm_cvtsd_si32 (__m128d a)
        ///CVTSD2SI r32, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtsd_si32", Category)]
        public int mm_cvtsd_si32(object a) => (int)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, int, int>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToInt32);
        
        /// <summary>
        /// Convert the lower double-precision (64-bit) floating-point element in "b" to a single-precision (32-bit) floating-point element, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128 _mm_cvtsd_ss (__m128 a, __m128d b)
        ///CVTSD2SS xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cvtsd_ss", Category)]
        public object mm_cvtsd_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse2.ConvertScalarToVector128Single);
        
        /// <summary>
        /// Copy the lower 32-bit integer in "a" to "dst".
        ///
        ///int _mm_cvtsi128_si32 (__m128i a)
        ///MOVD reg/m32, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtsi128_si32", Category)]
        public int mm_cvtsi128_si32(object a) => (int)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, int>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToInt32);
        
        /// <summary>
        /// Convert the 32-bit integer "b" to a double-precision (64-bit) floating-point element, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cvtsi32_sd (__m128d a, int b)
        ///CVTSI2SD xmm, reg/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cvtsi32_sd", Category)]
        public object mm_cvtsi32_sd(object a, int b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, int, int, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.ConvertScalarToVector128Double);
        
        /// <summary>
        /// Copy 32-bit integer "a" to the lower elements of "dst", and zero the upper elements of "dst".
        ///
        ///__m128i _mm_cvtsi32_si128 (int a)
        ///MOVD xmm, reg/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtsi32_si128", Category)]
        public object mm_cvtsi32_si128(int a) => (object)ProcessFunc<int, int, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertScalarToVector128Int32);
        
        /// <summary>
        /// Convert the lower single-precision (32-bit) floating-point element in "b" to a double-precision (64-bit) floating-point element, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cvtss_sd (__m128d a, __m128 b)
        ///CVTSS2SD xmm, xmm/m32
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cvtss_sd", Category)]
        public object mm_cvtss_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, float, System.Runtime.Intrinsics.Vector128<float>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.ConvertScalarToVector128Double);
        
        /// <summary>
        /// Convert packed double-precision (64-bit) floating-point elements in "a" to packed 32-bit integers with truncation, and store the results in "dst".
        ///
        ///__m128i _mm_cvttpd_epi32 (__m128d a)
        ///CVTTPD2DQ xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvttpd_epi32", Category)]
        public object mm_cvttpd_epi32(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Int32WithTruncation);
        
        /// <summary>
        /// Convert packed single-precision (32-bit) floating-point elements in "a" to packed 32-bit integers with truncation, and store the results in "dst".
        ///
        ///__m128i _mm_cvttps_epi32 (__m128 a)
        ///CVTTPS2DQ xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvttps_epi32", Category)]
        public object mm_cvttps_epi32(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToVector128Int32WithTruncation);
        
        /// <summary>
        /// Convert the lower double-precision (64-bit) floating-point element in "a" to a 32-bit integer with truncation, and store the result in "dst".
        ///
        ///int _mm_cvttsd_si32 (__m128d a)
        ///CVTTSD2SI reg, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvttsd_si32", Category)]
        public int mm_cvttsd_si32(object a) => (int)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, int, int>(a, System.Runtime.Intrinsics.X86.Sse2.ConvertToInt32WithTruncation);
        
        /// <summary>
        /// Divide packed double-precision (64-bit) floating-point elements in "a" by packed elements in "b", and store the results in "dst".
        ///
        ///__m128d _mm_div_pd (__m128d a,  __m128d b)
        ///DIVPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_div_pd", Category)]
        public object mm_div_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Divide);
        
        /// <summary>
        /// Divide the lower double-precision (64-bit) floating-point element in "a" by the lower double-precision (64-bit) floating-point element in "b", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_div_sd (__m128d a,  __m128d b)
        ///DIVSD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_div_sd", Category)]
        public object mm_div_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.DivideScalar);
        
        /// <summary>
        /// Extract a 16-bit integer from "a", selected with "imm8", and store the result in the lower element of "dst".
        ///
        ///int _mm_extract_epi16 (__m128i a,  int immediate)
        ///PEXTRW reg, xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_extract_epi16", Category)]
        public ushort mm_extract_epi16(object a, byte imm8) => (ushort)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, byte, byte, ushort, ushort>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.Extract);
        
        /// <summary>
        /// Copy "a" to "dst", and insert the 16-bit integer "i" into "dst" at the location specified by "imm8".
        ///
        ///__m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
        ///PINSRW xmm, reg/m16, imm8
        /// <param name="a"></param>
        /// <param name="i"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_insert_epi16", Category)]
        public object mm_insert_epi16(object a, short i, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, short, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, i, imm8, System.Runtime.Intrinsics.X86.Sse2.Insert);
        
        /// <summary>
        /// Load 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///__m128d _mm_load_pd (double const* mem_address)
        ///MOVAPD xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_load_pd", Category)]
        public object mm_load_pd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, 16, Sse2_LoadAlignedVector128194);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_LoadAlignedVector128194 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadAlignedVector128((double*)arg0));
        /// <summary>
        /// Load a double-precision (64-bit) floating-point element from memory into the lower of "dst", and zero the upper element. "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128d _mm_load_sd (double const* mem_address)
        ///MOVSD xmm, m64
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_load_sd", Category)]
        public object mm_load_sd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, Sse2_LoadScalarVector128204);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_LoadScalarVector128204 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadScalarVector128((double*)arg0));
        /// <summary>
        /// Load 128-bits of integer data from memory into "dst". 
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///__m128i _mm_load_si128 (__m128i const* mem_address)
        ///MOVDQA xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_load_si128", Category)]
        public object mm_load_si128(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(mem_addr, 16, Sse2_LoadAlignedVector128193);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Sse2_LoadAlignedVector128193 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadAlignedVector128((byte*)arg0));
        /// <summary>
        /// Load a double-precision (64-bit) floating-point element from memory into the upper element of "dst", and copy the lower element from "a" to "dst". "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128d _mm_loadh_pd (__m128d a, double const* mem_addr)
        ///MOVHPD xmm, m64
        /// <param name="a"></param>
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadh_pd", Category)]
        public object mm_loadh_pd(object a, object mem_addr) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(a, mem_addr, Sse2_LoadHigh202);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_LoadHigh202 = new Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.LoadHigh((System.Runtime.Intrinsics.Vector128<double>)arg0, (double*)arg1));
        /// <summary>
        /// __m128i _mm_loadl_epi32 (__m128i const* mem_addr)
        ///MOVD xmm, reg/m32
        /// <param name="address"></param>
        /// </summary>
        [KalkExport("mm_loadl_epi32", Category)]
        public object mm_loadl_epi32(object address) => (object)ProcessFunc<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(address, Sse2_LoadScalarVector128205);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>> Sse2_LoadScalarVector128205 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadScalarVector128((int*)arg0));
        /// <summary>
        /// Load 64-bit integer from memory into the first element of "dst".
        ///
        ///__m128i _mm_loadl_epi64 (__m128i const* mem_addr)
        ///MOVQ xmm, reg/m64
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadl_epi64", Category)]
        public object mm_loadl_epi64(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(mem_addr, Sse2_LoadScalarVector128206);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>> Sse2_LoadScalarVector128206 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadScalarVector128((long*)arg0));
        /// <summary>
        /// Load a double-precision (64-bit) floating-point element from memory into the lower element of "dst", and copy the upper element from "a" to "dst". "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128d _mm_loadl_pd (__m128d a, double const* mem_addr)
        ///MOVLPD xmm, m64
        /// <param name="a"></param>
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadl_pd", Category)]
        public object mm_loadl_pd(object a, object mem_addr) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(a, mem_addr, Sse2_LoadLow203);
        private unsafe readonly static Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_LoadLow203 = new Func<System.Runtime.Intrinsics.Vector128<double>, IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.LoadLow((System.Runtime.Intrinsics.Vector128<double>)arg0, (double*)arg1));
        /// <summary>
        /// Load 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from memory into "dst".
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128d _mm_loadu_pd (double const* mem_address)
        ///MOVUPD xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadu_pd", Category)]
        public object mm_loadu_pd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, Sse2_LoadVector128210);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_LoadVector128210 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadVector128((double*)arg0));
        /// <summary>
        /// Load 128-bits of integer data from memory into "dst".
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///__m128i _mm_loadu_si128 (__m128i const* mem_address)
        ///MOVDQU xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loadu_si128", Category)]
        public object mm_loadu_si128(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(mem_addr, Sse2_LoadVector128209);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Sse2_LoadVector128209 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0) => System.Runtime.Intrinsics.X86.Sse2.LoadVector128((byte*)arg0));
        /// <summary>
        /// Multiply packed signed 16-bit integers in "a" and "b", producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in "dst".
        ///
        ///__m128i _mm_madd_epi16 (__m128i a,  __m128i b)
        ///PMADDWD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_madd_epi16", Category)]
        public object mm_madd_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MultiplyAddAdjacent);
        
        /// <summary>
        /// Conditionally store 8-bit integer elements from "a" into memory using "mask" (elements are not stored when the highest bit is not set in the corresponding element) and a non-temporal memory hint. "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_maskmoveu_si128 (__m128i a,  __m128i mask, char* mem_address)
        ///MASKMOVDQU xmm, xmm
        /// <param name="a"></param>
        /// <param name="mask"></param>
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_maskmoveu_si128", Category)]
        public void mm_maskmoveu_si128(object a, object mask, object mem_addr) => ProcessAction<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, IntPtr, IntPtr>(a, mask, mem_addr, Sse2_MaskMove218);
        private unsafe readonly static Action<System.Runtime.Intrinsics.Vector128<byte>, System.Runtime.Intrinsics.Vector128<byte>, IntPtr> Sse2_MaskMove218 = new Action<System.Runtime.Intrinsics.Vector128<byte>, System.Runtime.Intrinsics.Vector128<byte>, IntPtr>((arg0, arg1, arg2) => System.Runtime.Intrinsics.X86.Sse2.MaskMove((System.Runtime.Intrinsics.Vector128<byte>)arg0, (System.Runtime.Intrinsics.Vector128<byte>)arg1, (byte*)arg2));
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128i _mm_max_epi16 (__m128i a,  __m128i b)
        ///PMAXSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_epi16", Category)]
        public object mm_max_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Max);
        
        /// <summary>
        /// Compare packed unsigned 8-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128i _mm_max_epu8 (__m128i a,  __m128i b)
        ///PMAXUB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_epu8", Category)]
        public object mm_max_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Max);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128d _mm_max_pd (__m128d a,  __m128d b)
        ///MAXPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_pd", Category)]
        public object mm_max_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Max);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b", store the maximum value in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_max_sd (__m128d a,  __m128d b)
        ///MAXSD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_sd", Category)]
        public object mm_max_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MaxScalar);
        
        /// <summary>
        /// Compare packed 16-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128i _mm_min_epi16 (__m128i a,  __m128i b)
        ///PMINSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_epi16", Category)]
        public object mm_min_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Min);
        
        /// <summary>
        /// Compare packed unsigned 8-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128i _mm_min_epu8 (__m128i a,  __m128i b)
        ///PMINUB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_epu8", Category)]
        public object mm_min_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Min);
        
        /// <summary>
        /// Compare packed double-precision (64-bit) floating-point elements in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128d _mm_min_pd (__m128d a,  __m128d b)
        ///MINPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_pd", Category)]
        public object mm_min_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Min);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point elements in "a" and "b", store the minimum value in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_min_sd (__m128d a,  __m128d b)
        ///MINSD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_sd", Category)]
        public object mm_min_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MinScalar);
        
        /// <summary>
        /// Copy the lower 64-bit integer in "a" to the lower element of "dst", and zero the upper element.
        ///
        ///__m128i _mm_move_epi64 (__m128i a)
        ///MOVQ xmm, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_move_epi64", Category)]
        public object mm_move_epi64(object a) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse2.MoveScalar);
        
        /// <summary>
        /// Move the lower double-precision (64-bit) floating-point element from "b" to the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_move_sd (__m128d a, __m128d b)
        ///MOVSD xmm, xmm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_move_sd", Category)]
        public object mm_move_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MoveScalar);
        
        /// <summary>
        /// Create mask from the most significant bit of each 8-bit element in "a", and store the result in "dst".
        ///
        ///int _mm_movemask_epi8 (__m128i a)
        ///PMOVMSKB reg, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_movemask_epi8", Category)]
        public int mm_movemask_epi8(object a) => (int)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, int, int>(a, System.Runtime.Intrinsics.X86.Sse2.MoveMask);
        
        /// <summary>
        /// Set each bit of mask "dst" based on the most significant bit of the corresponding packed double-precision (64-bit) floating-point element in "a".
        ///
        ///int _mm_movemask_pd (__m128d a)
        ///MOVMSKPD reg, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_movemask_pd", Category)]
        public int mm_movemask_pd(object a) => (int)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, int, int>(a, System.Runtime.Intrinsics.X86.Sse2.MoveMask);
        
        /// <summary>
        /// Multiply the low unsigned 32-bit integers from each packed 64-bit element in "a" and "b", and store the unsigned 64-bit results in "dst".
        ///
        ///__m128i _mm_mul_epu32 (__m128i a,  __m128i b)
        ///PMULUDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mul_epu32", Category)]
        public object mm_mul_epu32(object a, object b) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, ulong, System.Runtime.Intrinsics.Vector128<ulong>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Multiply);
        
        /// <summary>
        /// Multiply packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_mul_pd (__m128d a,  __m128d b)
        ///MULPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mul_pd", Category)]
        public object mm_mul_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Multiply);
        
        /// <summary>
        /// Multiply the lower double-precision (64-bit) floating-point element in "a" and "b", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_mul_sd (__m128d a,  __m128d b)
        ///MULSD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mul_sd", Category)]
        public object mm_mul_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MultiplyScalar);
        
        /// <summary>
        /// Multiply the packed 16-bit integers in "a" and "b", producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in "dst".
        ///
        ///__m128i _mm_mulhi_epi16 (__m128i a,  __m128i b)
        ///PMULHW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mulhi_epi16", Category)]
        public object mm_mulhi_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MultiplyHigh);
        
        /// <summary>
        /// Multiply the packed unsigned 16-bit integers in "a" and "b", producing intermediate 32-bit integers, and store the high 16 bits of the intermediate integers in "dst".
        ///
        ///__m128i _mm_mulhi_epu16 (__m128i a,  __m128i b)
        ///PMULHUW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mulhi_epu16", Category)]
        public object mm_mulhi_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MultiplyHigh);
        
        /// <summary>
        /// Multiply the packed 16-bit integers in "a" and "b", producing intermediate 32-bit integers, and store the low 16 bits of the intermediate integers in "dst".
        ///
        ///__m128i _mm_mullo_epi16 (__m128i a,  __m128i b)
        ///PMULLW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mullo_epi16", Category)]
        public object mm_mullo_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.MultiplyLow);
        
        /// <summary>
        /// Compute the bitwise OR of packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_or_pd (__m128d a,  __m128d b)
        ///ORPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_or_pd", Category)]
        public object mm_or_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Or);
        
        /// <summary>
        /// Compute the bitwise OR of 128 bits (representing integer data) in "a" and "b", and store the result in "dst".
        ///
        ///__m128i _mm_or_si128 (__m128i a,  __m128i b)
        ///POR xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_or_si128", Category)]
        public object mm_or_si128(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Or);
        
        /// <summary>
        /// Convert packed 16-bit integers from "a" and "b" to packed 8-bit integers using signed saturation, and store the results in "dst".
        ///
        ///__m128i _mm_packs_epi16 (__m128i a,  __m128i b)
        ///PACKSSWB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_packs_epi16", Category)]
        public object mm_packs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.PackSignedSaturate);
        
        /// <summary>
        /// Convert packed 32-bit integers from "a" and "b" to packed 16-bit integers using signed saturation, and store the results in "dst".
        ///
        ///__m128i _mm_packs_epi32 (__m128i a,  __m128i b)
        ///PACKSSDW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_packs_epi32", Category)]
        public object mm_packs_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.PackSignedSaturate);
        
        /// <summary>
        /// Convert packed 16-bit integers from "a" and "b" to packed 8-bit integers using unsigned saturation, and store the results in "dst".
        ///
        ///__m128i _mm_packus_epi16 (__m128i a,  __m128i b)
        ///PACKUSWB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_packus_epi16", Category)]
        public object mm_packus_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.PackUnsignedSaturate);
        
        /// <summary>
        /// Compute the absolute differences of packed unsigned 8-bit integers in "a" and "b", then horizontally sum each consecutive 8 differences to produce two unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low 16 bits of 64-bit elements in "dst".
        ///
        ///__m128i _mm_sad_epu8 (__m128i a,  __m128i b)
        ///PSADBW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sad_epu8", Category)]
        public object mm_sad_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SumAbsoluteDifferences);
        
        /// <summary>
        /// Shuffle 32-bit integers in "a" using the control in "imm8", and store the results in "dst".
        ///
        ///__m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
        ///PSHUFD xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_shuffle_epi32", Category)]
        public object mm_shuffle_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.Shuffle);
        
        /// <summary>
        /// Shuffle double-precision (64-bit) floating-point elements using the control in "imm8", and store the results in "dst".
        ///
        ///__m128d _mm_shuffle_pd (__m128d a,  __m128d b, int immediate)
        ///SHUFPD xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_shuffle_pd", Category)]
        public object mm_shuffle_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse2.Shuffle);
        
        /// <summary>
        /// Shuffle 16-bit integers in the high 64 bits of "a" using the control in "imm8". Store the results in the high 64 bits of "dst", with the low 64 bits being copied from from "a" to "dst".
        ///
        ///__m128i _mm_shufflehi_epi16 (__m128i a,  int immediate)
        ///PSHUFHW xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_shufflehi_epi16", Category)]
        public object mm_shufflehi_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShuffleHigh);
        
        /// <summary>
        /// Shuffle 16-bit integers in the low 64 bits of "a" using the control in "imm8". Store the results in the low 64 bits of "dst", with the high 64 bits being copied from from "a" to "dst".
        ///
        ///__m128i _mm_shufflelo_epi16 (__m128i a,  int control)
        ///PSHUFLW xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_shufflelo_epi16", Category)]
        public object mm_shufflelo_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShuffleLow);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" left by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_sll_epi16 (__m128i a, __m128i count)
        ///PSLLW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sll_epi16", Category)]
        public object mm_sll_epi16(object a, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" left by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_sll_epi32 (__m128i a, __m128i count)
        ///PSLLD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sll_epi32", Category)]
        public object mm_sll_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" left by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_sll_epi64 (__m128i a, __m128i count)
        ///PSLLQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sll_epi64", Category)]
        public object mm_sll_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" left by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_slli_epi16 (__m128i a,  int immediate)
        ///PSLLW xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_slli_epi16", Category)]
        public object mm_slli_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" left by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_slli_epi32 (__m128i a,  int immediate)
        ///PSLLD xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_slli_epi32", Category)]
        public object mm_slli_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" left by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_slli_epi64 (__m128i a,  int immediate)
        ///PSLLQ xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_slli_epi64", Category)]
        public object mm_slli_epi64(object a, byte imm8) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftLeftLogical);
        
        /// <summary>
        /// Compute the square root of packed double-precision (64-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m128d _mm_sqrt_pd (__m128d a)
        ///SQRTPD xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_sqrt_pd", Category)]
        public object mm_sqrt_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse2.Sqrt);
        
        /// <summary>
        /// Compute the square root of the lower double-precision (64-bit) floating-point element in "b", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_sqrt_sd (__m128d a, __m128d b)
        ///SQRTSD xmm, xmm/64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sqrt_sd", Category)]
        public object mm_sqrt_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SqrtScalar);
        
        /// <summary>
        /// Compute the square root of the lower double-precision (64-bit) floating-point element in "b", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_sqrt_sd (__m128d a)
        ///SQRTSD xmm, xmm/64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_sqrt_sd1", Category)]
        public object mm_sqrt_sd1(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse2.SqrtScalar);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "count" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m128i _mm_sra_epi16 (__m128i a, __m128i count)
        ///PSRAW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sra_epi16", Category)]
        public object mm_sra_epi16(object a, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftRightArithmetic);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "count" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m128i _mm_sra_epi32 (__m128i a, __m128i count)
        ///PSRAD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_sra_epi32", Category)]
        public object mm_sra_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftRightArithmetic);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "imm8" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m128i _mm_srai_epi16 (__m128i a,  int immediate)
        ///PSRAW xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_srai_epi16", Category)]
        public object mm_srai_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftRightArithmetic);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "imm8" while shifting in sign bits, and store the results in "dst".
        ///
        ///__m128i _mm_srai_epi32 (__m128i a,  int immediate)
        ///PSRAD xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_srai_epi32", Category)]
        public object mm_srai_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftRightArithmetic);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srl_epi16 (__m128i a, __m128i count)
        ///PSRLW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_srl_epi16", Category)]
        public object mm_srl_epi16(object a, object count) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srl_epi32 (__m128i a, __m128i count)
        ///PSRLD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_srl_epi32", Category)]
        public object mm_srl_epi32(object a, object count) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" right by "count" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srl_epi64 (__m128i a, __m128i count)
        ///PSRLQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_srl_epi64", Category)]
        public object mm_srl_epi64(object a, object count) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, count, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 16-bit integers in "a" right by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srli_epi16 (__m128i a,  int immediate)
        ///PSRLW xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_srli_epi16", Category)]
        public object mm_srli_epi16(object a, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 32-bit integers in "a" right by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srli_epi32 (__m128i a,  int immediate)
        ///PSRLD xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_srli_epi32", Category)]
        public object mm_srli_epi32(object a, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical);
        
        /// <summary>
        /// Shift packed 64-bit integers in "a" right by "imm8" while shifting in zeros, and store the results in "dst".
        ///
        ///__m128i _mm_srli_epi64 (__m128i a,  int immediate)
        ///PSRLQ xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_srli_epi64", Category)]
        public object mm_srli_epi64(object a, byte imm8) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(a, imm8, System.Runtime.Intrinsics.X86.Sse2.ShiftRightLogical);
        
        /// <summary>
        /// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm_store_pd (double* mem_addr, __m128d a)
        ///MOVAPD m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_store_pd", Category)]
        public void mm_store_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, 16, a, Sse2_StoreAligned318);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_StoreAligned318 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreAligned((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Store the lower double-precision (64-bit) floating-point element from "a" into memory. "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_store_sd (double* mem_addr, __m128d a)
        ///MOVSD m64, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_store_sd", Category)]
        public void mm_store_sd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, a, Sse2_StoreScalar339);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_StoreScalar339 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreScalar((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Store 128-bits of integer data from "a" into memory. 
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm_store_si128 (__m128i* mem_addr, __m128i a)
        ///MOVDQA m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_store_si128", Category)]
        public void mm_store_si128(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(mem_addr, 16, a, Sse2_StoreAligned317);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Sse2_StoreAligned317 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreAligned((byte*)arg0, (System.Runtime.Intrinsics.Vector128<byte>)arg1));
        /// <summary>
        /// Store the upper double-precision (64-bit) floating-point element from "a" into memory.
        ///
        ///void _mm_storeh_pd (double* mem_addr, __m128d a)
        ///MOVHPD m64, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storeh_pd", Category)]
        public void mm_storeh_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, a, Sse2_StoreHigh335);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_StoreHigh335 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreHigh((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Store 64-bit integer from the first element of "a" into memory.
        ///
        ///void _mm_storel_epi64 (__m128i* mem_addr, __m128i a)
        ///MOVQ m64, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storel_epi64", Category)]
        public void mm_storel_epi64(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, long, System.Runtime.Intrinsics.Vector128<long>>(mem_addr, a, Sse2_StoreScalar341);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>> Sse2_StoreScalar341 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<long>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreScalar((long*)arg0, (System.Runtime.Intrinsics.Vector128<long>)arg1));
        /// <summary>
        /// Store the lower double-precision (64-bit) floating-point element from "a" into memory.
        ///
        ///void _mm_storel_pd (double* mem_addr, __m128d a)
        ///MOVLPD m64, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storel_pd", Category)]
        public void mm_storel_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, a, Sse2_StoreLow336);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_StoreLow336 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreLow((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from "a" into memory.
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_storeu_pd (double* mem_addr, __m128d a)
        ///MOVUPD m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storeu_pd", Category)]
        public void mm_storeu_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, a, Sse2_Store309);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_Store309 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.Store((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Store 128-bits of integer data from "a" into memory.
        ///	"mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_storeu_si128 (__m128i* mem_addr, __m128i a)
        ///MOVDQU m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storeu_si128", Category)]
        public void mm_storeu_si128(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(mem_addr, a, Sse2_Store308);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Sse2_Store308 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.Store((byte*)arg0, (System.Runtime.Intrinsics.Vector128<byte>)arg1));
        /// <summary>
        /// Store 32-bit integer from the first element of "a" into memory. "mem_addr" does not need to be aligned on any particular boundary.
        ///
        ///void _mm_storeu_si32 (void* mem_addr, __m128i a) MOVD m32, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_storeu_si32", Category)]
        public void mm_storeu_si32(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, int, System.Runtime.Intrinsics.Vector128<int>>(mem_addr, a, Sse2_StoreScalar340);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>> Sse2_StoreScalar340 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<int>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreScalar((int*)arg0, (System.Runtime.Intrinsics.Vector128<int>)arg1));
        /// <summary>
        /// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) from "a" into memory using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm_stream_pd (double* mem_addr, __m128d a)
        ///MOVNTPD m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_stream_pd", Category)]
        public void mm_stream_pd(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, 16, a, Sse2_StoreAlignedNonTemporal327);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse2_StoreAlignedNonTemporal327 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreAlignedNonTemporal((double*)arg0, (System.Runtime.Intrinsics.Vector128<double>)arg1));
        /// <summary>
        /// Store 128-bits of integer data from "a" into memory using a non-temporal memory hint. 
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///void _mm_stream_si128 (__m128i* mem_addr, __m128i a)
        ///MOVNTDQ m128, xmm
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_stream_si128", Category)]
        public void mm_stream_si128(object mem_addr, object a) => ProcessAction<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(mem_addr, 16, a, Sse2_StoreAlignedNonTemporal326);
        private unsafe readonly static Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Sse2_StoreAlignedNonTemporal326 = new Action<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreAlignedNonTemporal((byte*)arg0, (System.Runtime.Intrinsics.Vector128<byte>)arg1));
        /// <summary>
        /// Store 32-bit integer "a" into memory using a non-temporal hint to minimize cache pollution. If the cache line containing address "mem_addr" is already in the cache, the cache will be updated.
        ///
        ///void _mm_stream_si32(int *p, int a)
        ///MOVNTI m32, r32
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_stream_si32", Category)]
        public void mm_stream_si32(object mem_addr, int a) => ProcessAction<IntPtr, IntPtr, int, int>(mem_addr, a, Sse2_StoreNonTemporal337);
        private unsafe readonly static Action<IntPtr, int> Sse2_StoreNonTemporal337 = new Action<IntPtr, int>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.StoreNonTemporal((int*)arg0, (int)arg1));
        /// <summary>
        /// Subtract packed 16-bit integers in "b" from packed 16-bit integers in "a", and store the results in "dst".
        ///
        ///__m128i _mm_sub_epi16 (__m128i a,  __m128i b)
        ///PSUBW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_epi16", Category)]
        public object mm_sub_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Subtract);
        
        /// <summary>
        /// Subtract packed 32-bit integers in "b" from packed 32-bit integers in "a", and store the results in "dst".
        ///
        ///__m128i _mm_sub_epi32 (__m128i a,  __m128i b)
        ///PSUBD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_epi32", Category)]
        public object mm_sub_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Subtract);
        
        /// <summary>
        /// Subtract packed 64-bit integers in "b" from packed 64-bit integers in "a", and store the results in "dst".
        ///
        ///__m128i _mm_sub_epi64 (__m128i a,  __m128i b)
        ///PSUBQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_epi64", Category)]
        public object mm_sub_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Subtract);
        
        /// <summary>
        /// Subtract packed 8-bit integers in "b" from packed 8-bit integers in "a", and store the results in "dst".
        ///
        ///__m128i _mm_sub_epi8 (__m128i a,  __m128i b)
        ///PSUBB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_epi8", Category)]
        public object mm_sub_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Subtract);
        
        /// <summary>
        /// Subtract packed double-precision (64-bit) floating-point elements in "b" from packed double-precision (64-bit) floating-point elements in "a", and store the results in "dst".
        ///
        ///__m128d _mm_sub_pd (__m128d a, __m128d b)
        ///SUBPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_pd", Category)]
        public object mm_sub_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Subtract);
        
        /// <summary>
        /// Subtract the lower double-precision (64-bit) floating-point element in "b" from the lower double-precision (64-bit) floating-point element in "a", store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_sub_sd (__m128d a, __m128d b)
        ///SUBSD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sub_sd", Category)]
        public object mm_sub_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SubtractScalar);
        
        /// <summary>
        /// Subtract packed 16-bit integers in "b" from packed 16-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_subs_epi16 (__m128i a,  __m128i b)
        ///PSUBSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_subs_epi16", Category)]
        public object mm_subs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SubtractSaturate);
        
        /// <summary>
        /// Subtract packed 8-bit integers in "b" from packed 8-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_subs_epi8 (__m128i a,  __m128i b)
        ///PSUBSB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_subs_epi8", Category)]
        public object mm_subs_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SubtractSaturate);
        
        /// <summary>
        /// Subtract packed unsigned 16-bit integers in "b" from packed unsigned 16-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_subs_epu16 (__m128i a,  __m128i b)
        ///PSUBUSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_subs_epu16", Category)]
        public object mm_subs_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SubtractSaturate);
        
        /// <summary>
        /// Subtract packed unsigned 8-bit integers in "b" from packed unsigned 8-bit integers in "a" using saturation, and store the results in "dst".
        ///
        ///__m128i _mm_subs_epu8 (__m128i a,  __m128i b)
        ///PSUBUSB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_subs_epu8", Category)]
        public object mm_subs_epu8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.SubtractSaturate);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for equality, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomieq_sd (__m128d a, __m128d b)
        ///UCOMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomieq_sd", Category)]
        public KalkBool mm_ucomieq_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnorderedEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for greater-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomige_sd (__m128d a, __m128d b)
        ///UCOMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomige_sd", Category)]
        public KalkBool mm_ucomige_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnorderedGreaterThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for greater-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomigt_sd (__m128d a, __m128d b)
        ///UCOMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomigt_sd", Category)]
        public KalkBool mm_ucomigt_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnorderedGreaterThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for less-than-or-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomile_sd (__m128d a, __m128d b)
        ///UCOMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomile_sd", Category)]
        public KalkBool mm_ucomile_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnorderedLessThanOrEqual);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for less-than, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomilt_sd (__m128d a, __m128d b)
        ///UCOMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomilt_sd", Category)]
        public KalkBool mm_ucomilt_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnorderedLessThan);
        
        /// <summary>
        /// Compare the lower double-precision (64-bit) floating-point element in "a" and "b" for not-equal, and return the boolean result (0 or 1). This instruction will not signal an exception for QNaNs.
        ///
        ///int _mm_ucomineq_sd (__m128d a, __m128d b)
        ///UCOMISD xmm, xmm/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ucomineq_sd", Category)]
        public KalkBool mm_ucomineq_sd(object a, object b) => (KalkBool)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse2.CompareScalarUnorderedNotEqual);
        
        /// <summary>
        /// Unpack and interleave 16-bit integers from the high half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpackhi_epi16 (__m128i a,  __m128i b)
        ///PUNPCKHWD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpackhi_epi16", Category)]
        public object mm_unpackhi_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 32-bit integers from the high half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpackhi_epi32 (__m128i a,  __m128i b)
        ///PUNPCKHDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpackhi_epi32", Category)]
        public object mm_unpackhi_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 64-bit integers from the high half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpackhi_epi64 (__m128i a,  __m128i b)
        ///PUNPCKHQDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpackhi_epi64", Category)]
        public object mm_unpackhi_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 8-bit integers from the high half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpackhi_epi8 (__m128i a,  __m128i b)
        ///PUNPCKHBW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpackhi_epi8", Category)]
        public object mm_unpackhi_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave double-precision (64-bit) floating-point elements from the high half of "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_unpackhi_pd (__m128d a,  __m128d b)
        ///UNPCKHPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpackhi_pd", Category)]
        public object mm_unpackhi_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackHigh);
        
        /// <summary>
        /// Unpack and interleave 16-bit integers from the low half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpacklo_epi16 (__m128i a,  __m128i b)
        ///PUNPCKLWD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpacklo_epi16", Category)]
        public object mm_unpacklo_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave 32-bit integers from the low half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpacklo_epi32 (__m128i a,  __m128i b)
        ///PUNPCKLDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpacklo_epi32", Category)]
        public object mm_unpacklo_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave 64-bit integers from the low half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpacklo_epi64 (__m128i a,  __m128i b)
        ///PUNPCKLQDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpacklo_epi64", Category)]
        public object mm_unpacklo_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave 8-bit integers from the low half of "a" and "b", and store the results in "dst".
        ///
        ///__m128i _mm_unpacklo_epi8 (__m128i a,  __m128i b)
        ///PUNPCKLBW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpacklo_epi8", Category)]
        public object mm_unpacklo_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackLow);
        
        /// <summary>
        /// Unpack and interleave double-precision (64-bit) floating-point elements from the low half of "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_unpacklo_pd (__m128d a,  __m128d b)
        ///UNPCKLPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_unpacklo_pd", Category)]
        public object mm_unpacklo_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.UnpackLow);
        
        /// <summary>
        /// Compute the bitwise XOR of packed double-precision (64-bit) floating-point elements in "a" and "b", and store the results in "dst".
        ///
        ///__m128d _mm_xor_pd (__m128d a,  __m128d b)
        ///XORPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_xor_pd", Category)]
        public object mm_xor_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Xor);
        
        /// <summary>
        /// Compute the bitwise XOR of 128 bits (representing integer data) in "a" and "b", and store the result in "dst".
        ///
        ///__m128i _mm_xor_si128 (__m128i a,  __m128i b)
        ///PXOR xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_xor_si128", Category)]
        public object mm_xor_si128(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Sse2.Xor);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse2X64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE2";

        /// <summary>
        /// Convert the lower double-precision (64-bit) floating-point element in "a" to a 64-bit integer, and store the result in "dst".
        ///
        ///__int64 _mm_cvtsd_si64 (__m128d a)
        ///CVTSD2SI r64, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtsd_si64", Category)]
        public long mm_cvtsd_si64(object a) => (long)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, long>(a, System.Runtime.Intrinsics.X86.Sse2.X64.ConvertToInt64);
        
        /// <summary>
        /// Copy the lower 64-bit integer in "a" to "dst".
        ///
        ///__int64 _mm_cvtsi128_si64 (__m128i a)
        ///MOVQ reg/m64, xmm
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtsi128_si64", Category)]
        public long mm_cvtsi128_si64(object a) => (long)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, long>(a, System.Runtime.Intrinsics.X86.Sse2.X64.ConvertToInt64);
        
        /// <summary>
        /// Convert the 64-bit integer "b" to a double-precision (64-bit) floating-point element, store the result in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_cvtsi64_sd (__m128d a, __int64 b)
        ///CVTSI2SD xmm, reg/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cvtsi64_sd", Category)]
        public object mm_cvtsi64_sd(object a, long b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, long, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse2.X64.ConvertScalarToVector128Double);
        
        /// <summary>
        /// Copy 64-bit integer "a" to the lower element of "dst", and zero the upper element.
        ///
        ///__m128i _mm_cvtsi64_si128 (__int64 a)
        ///MOVQ xmm, reg/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtsi64_si128", Category)]
        public object mm_cvtsi64_si128(long a) => (object)ProcessFunc<long, long, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse2.X64.ConvertScalarToVector128Int64);
        
        /// <summary>
        /// Convert the lower double-precision (64-bit) floating-point element in "a" to a 64-bit integer with truncation, and store the result in "dst".
        ///
        ///__int64 _mm_cvttsd_si64 (__m128d a)
        ///CVTTSD2SI reg, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvttsd_si64", Category)]
        public long mm_cvttsd_si64(object a) => (long)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, long, long>(a, System.Runtime.Intrinsics.X86.Sse2.X64.ConvertToInt64WithTruncation);
        
        /// <summary>
        /// Store 64-bit integer "a" into memory using a non-temporal hint to minimize cache pollution. If the cache line containing address "mem_addr" is already in the cache, the cache will be updated.
        ///
        ///void _mm_stream_si64(__int64 *p, __int64 a)
        ///MOVNTI m64, r64
        /// <param name="mem_addr"></param>
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_stream_si64", Category)]
        public void mm_stream_si64(object mem_addr, long a) => ProcessAction<IntPtr, IntPtr, long, long>(mem_addr, a, Sse2X64_StoreNonTemporal393);
        private unsafe readonly static Action<IntPtr, long> Sse2X64_StoreNonTemporal393 = new Action<IntPtr, long>((arg0, arg1) => System.Runtime.Intrinsics.X86.Sse2.X64.StoreNonTemporal((long*)arg0, (long)arg1));
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse3IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE3";

        /// <summary>
        /// Alternatively add and subtract packed double-precision (64-bit) floating-point elements in "a" to/from packed elements in "b", and store the results in "dst".
        ///
        ///__m128d _mm_addsub_pd (__m128d a, __m128d b)
        ///ADDSUBPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_addsub_pd", Category)]
        public object mm_addsub_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse3.AddSubtract);
        
        /// <summary>
        /// Alternatively add and subtract packed single-precision (32-bit) floating-point elements in "a" to/from packed elements in "b", and store the results in "dst".
        ///
        ///__m128 _mm_addsub_ps (__m128 a, __m128 b)
        ///ADDSUBPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_addsub_ps", Category)]
        public object mm_addsub_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse3.AddSubtract);
        
        /// <summary>
        /// Horizontally add adjacent pairs of double-precision (64-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m128d _mm_hadd_pd (__m128d a, __m128d b)
        ///HADDPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hadd_pd", Category)]
        public object mm_hadd_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse3.HorizontalAdd);
        
        /// <summary>
        /// Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m128 _mm_hadd_ps (__m128 a, __m128 b)
        ///HADDPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hadd_ps", Category)]
        public object mm_hadd_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse3.HorizontalAdd);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of double-precision (64-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m128d _mm_hsub_pd (__m128d a, __m128d b)
        ///HSUBPD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hsub_pd", Category)]
        public object mm_hsub_pd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse3.HorizontalSubtract);
        
        /// <summary>
        /// Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in "a" and "b", and pack the results in "dst".
        ///
        ///__m128 _mm_hsub_ps (__m128 a, __m128 b)
        ///HSUBPS xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hsub_ps", Category)]
        public object mm_hsub_ps(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse3.HorizontalSubtract);
        
        /// <summary>
        /// Load 128-bits of integer data from unaligned memory into "dst". This intrinsic may perform better than "_mm_loadu_si128" when the data crosses a cache line boundary.
        ///
        ///__m128i _mm_lddqu_si128 (__m128i const* mem_addr)
        ///LDDQU xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_lddqu_si128", Category)]
        public object mm_lddqu_si128(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(mem_addr, Sse3_LoadDquVector128402);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>> Sse3_LoadDquVector128402 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<sbyte>>((arg0) => System.Runtime.Intrinsics.X86.Sse3.LoadDquVector128((sbyte*)arg0));
        /// <summary>
        /// Load a double-precision (64-bit) floating-point element from memory into both elements of "dst".
        ///
        ///__m128d _mm_loaddup_pd (double const* mem_addr)
        ///MOVDDUP xmm, m64
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_loaddup_pd", Category)]
        public object mm_loaddup_pd(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, double, System.Runtime.Intrinsics.Vector128<double>>(mem_addr, Sse3_LoadAndDuplicateToVector128401);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>> Sse3_LoadAndDuplicateToVector128401 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<double>>((arg0) => System.Runtime.Intrinsics.X86.Sse3.LoadAndDuplicateToVector128((double*)arg0));
        /// <summary>
        /// Duplicate the low double-precision (64-bit) floating-point element from "a", and store the results in "dst".
        ///
        ///__m128d _mm_movedup_pd (__m128d a)
        ///MOVDDUP xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_movedup_pd", Category)]
        public object mm_movedup_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse3.MoveAndDuplicate);
        
        /// <summary>
        /// Duplicate odd-indexed single-precision (32-bit) floating-point elements from "a", and store the results in "dst".
        ///
        ///__m128 _mm_movehdup_ps (__m128 a)
        ///MOVSHDUP xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_movehdup_ps", Category)]
        public object mm_movehdup_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse3.MoveHighAndDuplicate);
        
        /// <summary>
        /// Duplicate even-indexed single-precision (32-bit) floating-point elements from "a", and store the results in "dst".
        ///
        ///__m128 _mm_moveldup_ps (__m128 a)
        ///MOVSLDUP xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_moveldup_ps", Category)]
        public object mm_moveldup_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse3.MoveLowAndDuplicate);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse41IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE41";

        /// <summary>
        /// Blend packed 16-bit integers from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
        ///PBLENDW xmm, xmm/m128 imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_blend_epi16", Category)]
        public object mm_blend_epi16(object a, object b, byte imm8) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, byte, byte, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.Blend);
        
        /// <summary>
        /// Blend packed double-precision (64-bit) floating-point elements from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8)
        ///BLENDPD xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_blend_pd", Category)]
        public object mm_blend_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.Blend);
        
        /// <summary>
        /// Blend packed single-precision (32-bit) floating-point elements from "a" and "b" using control mask "imm8", and store the results in "dst".
        ///
        ///__m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8)
        ///BLENDPS xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_blend_ps", Category)]
        public object mm_blend_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.Blend);
        
        /// <summary>
        /// Blend packed 8-bit integers from "a" and "b" using "mask", and store the results in "dst".
        ///
        ///__m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
        ///PBLENDVB xmm, xmm/m128, xmm
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_blendv_epi8", Category)]
        public object mm_blendv_epi8(object a, object b, object mask) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, mask, System.Runtime.Intrinsics.X86.Sse41.BlendVariable);
        
        /// <summary>
        /// Blend packed double-precision (64-bit) floating-point elements from "a" and "b" using "mask", and store the results in "dst".
        ///
        ///__m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask)
        ///BLENDVPD xmm, xmm/m128, xmm0
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_blendv_pd", Category)]
        public object mm_blendv_pd(object a, object b, object mask) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, mask, System.Runtime.Intrinsics.X86.Sse41.BlendVariable);
        
        /// <summary>
        /// Blend packed single-precision (32-bit) floating-point elements from "a" and "b" using "mask", and store the results in "dst".
        ///
        ///__m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask)
        ///BLENDVPS xmm, xmm/m128, xmm0
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="mask"></param>
        /// </summary>
        [KalkExport("mm_blendv_ps", Category)]
        public object mm_blendv_ps(object a, object b, object mask) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, mask, System.Runtime.Intrinsics.X86.Sse41.BlendVariable);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" up to an integer value, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_ceil_pd (__m128d a)
        ///ROUNDPD xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_ceil_pd", Category)]
        public object mm_ceil_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.Ceiling);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" up to an integer value, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_ceil_ps (__m128 a)
        ///ROUNDPS xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_ceil_ps", Category)]
        public object mm_ceil_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.Ceiling);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" up to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_ceil_sd (__m128d a, __m128d b)
        ///ROUNDSD xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ceil_sd", Category)]
        public object mm_ceil_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.CeilingScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" up to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_ceil_sd (__m128d a)
        ///ROUNDSD xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_ceil_sd1", Category)]
        public object mm_ceil_sd1(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.CeilingScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" up to an integer value, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_ceil_ss (__m128 a, __m128 b)
        ///ROUNDSS xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_ceil_ss", Category)]
        public object mm_ceil_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.CeilingScalar);
        
        /// <summary>
        /// Compare packed 64-bit integers in "a" and "b" for equality, and store the results in "dst".
        ///
        ///__m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
        ///PCMPEQQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpeq_epi64", Category)]
        public object mm_cmpeq_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse41.CompareEqual);
        
        /// <summary>
        /// Sign extend packed 16-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepi16_epi32 (__m128i a)
        ///PMOVSXWD xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi16_epi32", Category)]
        public object mm_cvtepi16_epi32(object a) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int32);
        
        /// <summary>
        /// Sign extend packed 16-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepi16_epi64 (__m128i a)
        ///PMOVSXWQ xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi16_epi64", Category)]
        public object mm_cvtepi16_epi64(object a) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int64);
        
        /// <summary>
        /// Sign extend packed 32-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepi32_epi64 (__m128i a)
        ///PMOVSXDQ xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi32_epi64", Category)]
        public object mm_cvtepi32_epi64(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int64);
        
        /// <summary>
        /// Sign extend packed 8-bit integers in "a" to packed 16-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepi8_epi16 (__m128i a)
        ///PMOVSXBW xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi8_epi16", Category)]
        public object mm_cvtepi8_epi16(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int16);
        
        /// <summary>
        /// Sign extend packed 8-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepi8_epi32 (__m128i a)
        ///PMOVSXBD xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi8_epi32", Category)]
        public object mm_cvtepi8_epi32(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int32);
        
        /// <summary>
        /// Sign extend packed 8-bit integers in the low 8 bytes of "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepi8_epi64 (__m128i a)
        ///PMOVSXBQ xmm, xmm/m16
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepi8_epi64", Category)]
        public object mm_cvtepi8_epi64(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int64);
        
        /// <summary>
        /// Zero extend packed unsigned 16-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepu16_epi32 (__m128i a)
        ///PMOVZXWD xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepu16_epi32", Category)]
        public object mm_cvtepu16_epi32(object a) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int32);
        
        /// <summary>
        /// Zero extend packed unsigned 16-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepu16_epi64 (__m128i a)
        ///PMOVZXWQ xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepu16_epi64", Category)]
        public object mm_cvtepu16_epi64(object a) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int64);
        
        /// <summary>
        /// Zero extend packed unsigned 32-bit integers in "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepu32_epi64 (__m128i a)
        ///PMOVZXDQ xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepu32_epi64", Category)]
        public object mm_cvtepu32_epi64(object a) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int64);
        
        /// <summary>
        /// Zero extend packed unsigned 8-bit integers in "a" to packed 16-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepu8_epi16 (__m128i a)
        ///PMOVZXBW xmm, xmm/m64
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepu8_epi16", Category)]
        public object mm_cvtepu8_epi16(object a) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, short, System.Runtime.Intrinsics.Vector128<short>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int16);
        
        /// <summary>
        /// Zero extend packed unsigned 8-bit integers in "a" to packed 32-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepu8_epi32 (__m128i a)
        ///PMOVZXBD xmm, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepu8_epi32", Category)]
        public object mm_cvtepu8_epi32(object a) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, int, System.Runtime.Intrinsics.Vector128<int>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int32);
        
        /// <summary>
        /// Zero extend packed unsigned 8-bit integers in the low 8 byte sof "a" to packed 64-bit integers, and store the results in "dst".
        ///
        ///__m128i _mm_cvtepu8_epi64 (__m128i a)
        ///PMOVZXBQ xmm, xmm/m16
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtepu8_epi64", Category)]
        public object mm_cvtepu8_epi64(object a) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, long, System.Runtime.Intrinsics.Vector128<long>>(a, System.Runtime.Intrinsics.X86.Sse41.ConvertToVector128Int64);
        
        /// <summary>
        /// Conditionally multiply the packed double-precision (64-bit) floating-point elements in "a" and "b" using the high 4 bits in "imm8", sum the four products, and conditionally store the sum in "dst" using the low 4 bits of "imm8".
        ///
        ///__m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8)
        ///DPPD xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_dp_pd", Category)]
        public object mm_dp_pd(object a, object b, byte imm8) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, byte, byte, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.DotProduct);
        
        /// <summary>
        /// Conditionally multiply the packed single-precision (32-bit) floating-point elements in "a" and "b" using the high 4 bits in "imm8", sum the four products, and conditionally store the sum in "dst" using the low 4 bits of "imm8".
        ///
        ///__m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8)
        ///DPPS xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_dp_ps", Category)]
        public object mm_dp_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.DotProduct);
        
        /// <summary>
        /// Extract a 32-bit integer from "a", selected with "imm8", and store the result in "dst".
        ///
        ///int _mm_extract_epi32 (__m128i a, const int imm8)
        ///PEXTRD reg/m32, xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_extract_epi32", Category)]
        public int mm_extract_epi32(object a, byte imm8) => (int)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, byte, byte, int, int>(a, imm8, System.Runtime.Intrinsics.X86.Sse41.Extract);
        
        /// <summary>
        /// Extract an 8-bit integer from "a", selected with "imm8", and store the result in the lower element of "dst".
        ///
        ///int _mm_extract_epi8 (__m128i a, const int imm8)
        ///PEXTRB reg/m8, xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_extract_epi8", Category)]
        public byte mm_extract_epi8(object a, byte imm8) => (byte)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, byte>(a, imm8, System.Runtime.Intrinsics.X86.Sse41.Extract);
        
        /// <summary>
        /// Extract a single-precision (32-bit) floating-point element from "a", selected with "imm8", and store the result in "dst".
        ///
        ///int _mm_extract_ps (__m128 a, const int imm8)
        ///EXTRACTPS xmm, xmm/m32, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_extract_ps", Category)]
        public float mm_extract_ps(object a, byte imm8) => (float)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, float>(a, imm8, System.Runtime.Intrinsics.X86.Sse41.Extract);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" down to an integer value, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_floor_pd (__m128d a)
        ///ROUNDPD xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_floor_pd", Category)]
        public object mm_floor_pd(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.Floor);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" down to an integer value, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_floor_ps (__m128 a)
        ///ROUNDPS xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_floor_ps", Category)]
        public object mm_floor_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.Floor);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" down to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_floor_sd (__m128d a, __m128d b)
        ///ROUNDSD xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_floor_sd", Category)]
        public object mm_floor_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.FloorScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" down to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_floor_sd (__m128d a)
        ///ROUNDSD xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_floor_sd1", Category)]
        public object mm_floor_sd1(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.FloorScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" down to an integer value, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_floor_ss (__m128 a, __m128 b)
        ///ROUNDSS xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_floor_ss", Category)]
        public object mm_floor_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.FloorScalar);
        
        /// <summary>
        /// Copy "a" to "dst", and insert the 32-bit integer "i" into "dst" at the location specified by "imm8".
        ///
        ///__m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
        ///PINSRD xmm, reg/m32, imm8
        /// <param name="a"></param>
        /// <param name="i"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_insert_epi32", Category)]
        public object mm_insert_epi32(object a, int i, byte imm8) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, int, byte, byte, int, System.Runtime.Intrinsics.Vector128<int>>(a, i, imm8, System.Runtime.Intrinsics.X86.Sse41.Insert);
        
        /// <summary>
        /// Copy "a" to "dst", and insert the lower 8-bit integer from "i" into "dst" at the location specified by "imm8".
        ///
        ///__m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
        ///PINSRB xmm, reg/m8, imm8
        /// <param name="a"></param>
        /// <param name="i"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_insert_epi8", Category)]
        public object mm_insert_epi8(object a, byte i, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, i, imm8, System.Runtime.Intrinsics.X86.Sse41.Insert);
        
        /// <summary>
        /// Copy "a" to "tmp", then insert a single-precision (32-bit) floating-point element from "b" into "tmp" using the control in "imm8". Store "tmp" to "dst" using the mask in "imm8" (elements are zeroed out when the corresponding bit is set).
        ///
        ///__m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8)
        ///INSERTPS xmm, xmm/m32, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_insert_ps", Category)]
        public object mm_insert_ps(object a, object b, byte imm8) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, byte, byte, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.Insert);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128i _mm_max_epi32 (__m128i a, __m128i b)
        ///PMAXSD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_epi32", Category)]
        public object mm_max_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Max);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128i _mm_max_epi8 (__m128i a, __m128i b)
        ///PMAXSB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_epi8", Category)]
        public object mm_max_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Max);
        
        /// <summary>
        /// Compare packed unsigned 16-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128i _mm_max_epu16 (__m128i a, __m128i b)
        ///PMAXUW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_epu16", Category)]
        public object mm_max_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Max);
        
        /// <summary>
        /// Compare packed unsigned 32-bit integers in "a" and "b", and store packed maximum values in "dst".
        ///
        ///__m128i _mm_max_epu32 (__m128i a, __m128i b)
        ///PMAXUD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_max_epu32", Category)]
        public object mm_max_epu32(object a, object b) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Max);
        
        /// <summary>
        /// Compare packed 32-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128i _mm_min_epi32 (__m128i a, __m128i b)
        ///PMINSD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_epi32", Category)]
        public object mm_min_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Min);
        
        /// <summary>
        /// Compare packed 8-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128i _mm_min_epi8 (__m128i a, __m128i b)
        ///PMINSB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_epi8", Category)]
        public object mm_min_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Min);
        
        /// <summary>
        /// Compare packed unsigned 16-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128i _mm_min_epu16 (__m128i a, __m128i b)
        ///PMINUW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_epu16", Category)]
        public object mm_min_epu16(object a, object b) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Min);
        
        /// <summary>
        /// Compare packed unsigned 32-bit integers in "a" and "b", and store packed minimum values in "dst".
        ///
        ///__m128i _mm_min_epu32 (__m128i a, __m128i b)
        ///PMINUD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_min_epu32", Category)]
        public object mm_min_epu32(object a, object b) => (object)ProcessFunc<uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>, uint, System.Runtime.Intrinsics.Vector128<uint>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Min);
        
        /// <summary>
        /// Horizontally compute the minimum amongst the packed unsigned 16-bit integers in "a", store the minimum and index in "dst", and zero the remaining bits in "dst".
        ///
        ///__m128i _mm_minpos_epu16 (__m128i a)
        ///PHMINPOSUW xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_minpos_epu16", Category)]
        public object mm_minpos_epu16(object a) => (object)ProcessFunc<ushort, System.Runtime.Intrinsics.Vector128<ushort>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, System.Runtime.Intrinsics.X86.Sse41.MinHorizontal);
        
        /// <summary>
        /// Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in "a" compared to those in "b", and store the 16-bit results in "dst".
        ///	Eight SADs are performed using one quadruplet from "b" and eight quadruplets from "a". One quadruplet is selected from "b" starting at on the offset specified in "imm8". Eight quadruplets are formed from sequential 8-bit integers selected from "a" starting at the offset specified in "imm8".
        ///
        ///__m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8)
        ///MPSADBW xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_mpsadbw_epu8", Category)]
        public object mm_mpsadbw_epu8(object a, object b, byte imm8) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, imm8, System.Runtime.Intrinsics.X86.Sse41.MultipleSumAbsoluteDifferences);
        
        /// <summary>
        /// Multiply the low 32-bit integers from each packed 64-bit element in "a" and "b", and store the signed 64-bit results in "dst".
        ///
        ///__m128i _mm_mul_epi32 (__m128i a, __m128i b)
        ///PMULDQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mul_epi32", Category)]
        public object mm_mul_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse41.Multiply);
        
        /// <summary>
        /// Multiply the packed 32-bit integers in "a" and "b", producing intermediate 64-bit integers, and store the low 32 bits of the intermediate integers in "dst".
        ///
        ///__m128i _mm_mullo_epi32 (__m128i a, __m128i b)
        ///PMULLD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mullo_epi32", Category)]
        public object mm_mullo_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Sse41.MultiplyLow);
        
        /// <summary>
        /// Convert packed 32-bit integers from "a" and "b" to packed 16-bit integers using unsigned saturation, and store the results in "dst".
        ///
        ///__m128i _mm_packus_epi32 (__m128i a, __m128i b)
        ///PACKUSDW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_packus_epi32", Category)]
        public object mm_packus_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, b, System.Runtime.Intrinsics.X86.Sse41.PackUnsignedSaturate);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_round_pd (__m128d a, _MM_FROUND_CUR_DIRECTION); ROUNDPD xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_pd1", Category)]
        public object mm_round_pd1(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundCurrentDirection);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_round_pd (__m128d a, int rounding)
        ///ROUNDPD xmm, xmm/m128, imm8(8)
        ///            _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_pd1_to_nearest_integer", Category)]
        public object mm_round_pd1_to_nearest_integer(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNearestInteger);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_round_pd (__m128d a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC); ROUNDPD xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_pd1_to_negative_infinity", Category)]
        public object mm_round_pd1_to_negative_infinity(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNegativeInfinity);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_round_pd (__m128d a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC); ROUNDPD xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_pd1_to_positive_infinity", Category)]
        public object mm_round_pd1_to_positive_infinity(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToPositiveInfinity);
        
        /// <summary>
        /// Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".
        ///
        ///__m128d _mm_round_pd (__m128d a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC); ROUNDPD xmm, xmm/m128, imm8(11)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_pd1_to_zero", Category)]
        public object mm_round_pd1_to_zero(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToZero);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_round_ps (__m128 a, _MM_FROUND_CUR_DIRECTION); ROUNDPS xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ps", Category)]
        public object mm_round_ps(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundCurrentDirection);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_round_ps (__m128 a, int rounding)
        ///ROUNDPS xmm, xmm/m128, imm8(8)
        ///            _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ps_to_nearest_integer", Category)]
        public object mm_round_ps_to_nearest_integer(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNearestInteger);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC); ROUNDPS xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ps_to_negative_infinity", Category)]
        public object mm_round_ps_to_negative_infinity(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNegativeInfinity);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC); ROUNDPS xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ps_to_positive_infinity", Category)]
        public object mm_round_ps_to_positive_infinity(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToPositiveInfinity);
        
        /// <summary>
        /// Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".
        ///
        ///__m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC); ROUNDPS xmm, xmm/m128, imm8(11)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ps_to_zero", Category)]
        public object mm_round_ps_to_zero(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToZero);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_CUR_DIRECTION)
        ///ROUNDSD xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_sd", Category)]
        public object mm_round_sd(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundCurrentDirectionScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(8)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_sd_to_nearest_integer_scalar", Category)]
        public object mm_round_sd_to_nearest_integer_scalar(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToNearestIntegerScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_sd_to_negative_infinity_scalar", Category)]
        public object mm_round_sd_to_negative_infinity_scalar(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_sd_to_positive_infinity_scalar", Category)]
        public object mm_round_sd_to_positive_infinity_scalar(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(11)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_sd_to_zero_scalar", Category)]
        public object mm_round_sd_to_zero_scalar(object a, object b) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToZeroScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, _MM_FROUND_CUR_DIRECTION)
        ///ROUNDSD xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_sd1", Category)]
        public object mm_round_sd1(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundCurrentDirectionScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(8)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_sd1_to_nearest_integer_scalar", Category)]
        public object mm_round_sd1_to_nearest_integer_scalar(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNearestIntegerScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_sd1_to_negative_infinity_scalar", Category)]
        public object mm_round_sd1_to_negative_infinity_scalar(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_sd1_to_positive_infinity_scalar", Category)]
        public object mm_round_sd1_to_positive_infinity_scalar(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".
        ///
        ///__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC)
        ///ROUNDSD xmm, xmm/m128, imm8(11)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_sd1_to_zero_scalar", Category)]
        public object mm_round_sd1_to_zero_scalar(object a) => (object)ProcessFunc<double, System.Runtime.Intrinsics.Vector128<double>, double, System.Runtime.Intrinsics.Vector128<double>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToZeroScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_CUR_DIRECTION)
        ///ROUNDSS xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_ss", Category)]
        public object mm_round_ss(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundCurrentDirectionScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(8)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_ss_to_nearest_integer_scalar", Category)]
        public object mm_round_ss_to_nearest_integer_scalar(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToNearestIntegerScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_ss_to_negative_infinity_scalar", Category)]
        public object mm_round_ss_to_negative_infinity_scalar(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_ss_to_positive_infinity_scalar", Category)]
        public object mm_round_ss_to_positive_infinity_scalar(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(11)
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_round_ss_to_zero_scalar", Category)]
        public object mm_round_ss_to_zero_scalar(object a, object b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse41.RoundToZeroScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, _MM_FROUND_CUR_DIRECTION)
        ///ROUNDSS xmm, xmm/m128, imm8(4)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ss1", Category)]
        public object mm_round_ss1(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundCurrentDirectionScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(8)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ss1_to_nearest_integer_scalar", Category)]
        public object mm_round_ss1_to_nearest_integer_scalar(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNearestIntegerScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(9)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ss1_to_negative_infinity_scalar", Category)]
        public object mm_round_ss1_to_negative_infinity_scalar(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToNegativeInfinityScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(10)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ss1_to_positive_infinity_scalar", Category)]
        public object mm_round_ss1_to_positive_infinity_scalar(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToPositiveInfinityScalar);
        
        /// <summary>
        /// Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)
        ///ROUNDSS xmm, xmm/m128, imm8(11)
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_round_ss1_to_zero_scalar", Category)]
        public object mm_round_ss1_to_zero_scalar(object a) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, float, System.Runtime.Intrinsics.Vector128<float>>(a, System.Runtime.Intrinsics.X86.Sse41.RoundToZeroScalar);
        
        /// <summary>
        /// Load 128-bits of integer data from memory into "dst" using a non-temporal memory hint.
        ///	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.
        ///
        ///__m128i _mm_stream_load_si128 (const __m128i* mem_addr)
        ///MOVNTDQA xmm, m128
        /// <param name="mem_addr"></param>
        /// </summary>
        [KalkExport("mm_stream_load_si128", Category)]
        public object mm_stream_load_si128(object mem_addr) => (object)ProcessFunc<IntPtr, IntPtr, byte, System.Runtime.Intrinsics.Vector128<byte>>(mem_addr, 16, Sse41_LoadAlignedVector128NonTemporal481);
        private unsafe readonly static Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>> Sse41_LoadAlignedVector128NonTemporal481 = new Func<IntPtr, System.Runtime.Intrinsics.Vector128<byte>>((arg0) => System.Runtime.Intrinsics.X86.Sse41.LoadAlignedVector128NonTemporal((byte*)arg0));
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return the "CF" value.
        ///
        ///int _mm_testc_si128 (__m128i a, __m128i b)
        ///PTEST xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testc_si128", Category)]
        public KalkBool mm_testc_si128(object a, object b) => (KalkBool)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse41.TestC);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.
        ///
        ///int _mm_testnzc_si128 (__m128i a, __m128i b)
        ///PTEST xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testnzc_si128", Category)]
        public KalkBool mm_testnzc_si128(object a, object b) => (KalkBool)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse41.TestNotZAndNotC);
        
        /// <summary>
        /// Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return the "ZF" value.
        ///
        ///int _mm_testz_si128 (__m128i a, __m128i b)
        ///PTEST xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_testz_si128", Category)]
        public KalkBool mm_testz_si128(object a, object b) => (KalkBool)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, bool, bool>(a, b, System.Runtime.Intrinsics.X86.Sse41.TestZ);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse41X64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE41";

        /// <summary>
        /// Extract a 64-bit integer from "a", selected with "imm8", and store the result in "dst".
        ///
        ///__int64 _mm_extract_epi64 (__m128i a, const int imm8)
        ///PEXTRQ reg/m64, xmm, imm8
        /// <param name="a"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_extract_epi64", Category)]
        public long mm_extract_epi64(object a, byte imm8) => (long)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, byte, byte, long, long>(a, imm8, System.Runtime.Intrinsics.X86.Sse41.X64.Extract);
        
        /// <summary>
        /// Copy "a" to "dst", and insert the 64-bit integer "i" into "dst" at the location specified by "imm8".
        ///
        ///__m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
        ///PINSRQ xmm, reg/m64, imm8
        /// <param name="a"></param>
        /// <param name="i"></param>
        /// <param name="imm8"></param>
        /// </summary>
        [KalkExport("mm_insert_epi64", Category)]
        public object mm_insert_epi64(object a, long i, byte imm8) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, long, byte, byte, long, System.Runtime.Intrinsics.Vector128<long>>(a, i, imm8, System.Runtime.Intrinsics.X86.Sse41.X64.Insert);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse42IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE42";

        /// <summary>
        /// Compare packed 64-bit integers in "a" and "b" for greater-than, and store the results in "dst".
        ///
        ///__m128i _mm_cmpgt_epi64 (__m128i a, __m128i b)
        ///PCMPGTQ xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cmpgt_epi64", Category)]
        public object mm_cmpgt_epi64(object a, object b) => (object)ProcessFunc<long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>, long, System.Runtime.Intrinsics.Vector128<long>>(a, b, System.Runtime.Intrinsics.X86.Sse42.CompareGreaterThan);
        
        /// <summary>
        /// Starting with the initial value in "crc", accumulates a CRC32 value for unsigned 16-bit integer "v", and stores the result in "dst".
        ///
        ///unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v)
        ///CRC32 reg, reg/m16
        /// <param name="crc"></param>
        /// <param name="v"></param>
        /// </summary>
        [KalkExport("mm_crc32_u16", Category)]
        public uint mm_crc32_u16(uint crc, ushort v) => (uint)ProcessFunc<uint, uint, ushort, ushort, uint, uint>(crc, v, System.Runtime.Intrinsics.X86.Sse42.Crc32);
        
        /// <summary>
        /// Starting with the initial value in "crc", accumulates a CRC32 value for unsigned 32-bit integer "v", and stores the result in "dst".
        ///
        ///unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v)
        ///CRC32 reg, reg/m32
        /// <param name="crc"></param>
        /// <param name="v"></param>
        /// </summary>
        [KalkExport("mm_crc32_u32", Category)]
        public uint mm_crc32_u32(uint crc, uint v) => (uint)ProcessFunc<uint, uint, uint, uint, uint, uint>(crc, v, System.Runtime.Intrinsics.X86.Sse42.Crc32);
        
        /// <summary>
        /// Starting with the initial value in "crc", accumulates a CRC32 value for unsigned 8-bit integer "v", and stores the result in "dst".
        ///
        ///unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v)
        ///CRC32 reg, reg/m8
        /// <param name="crc"></param>
        /// <param name="v"></param>
        /// </summary>
        [KalkExport("mm_crc32_u8", Category)]
        public uint mm_crc32_u8(uint crc, byte v) => (uint)ProcessFunc<uint, uint, byte, byte, uint, uint>(crc, v, System.Runtime.Intrinsics.X86.Sse42.Crc32);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Sse42X64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE42";

        /// <summary>
        /// Starting with the initial value in "crc", accumulates a CRC32 value for unsigned 64-bit integer "v", and stores the result in "dst".
        ///
        ///unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v)
        ///CRC32 reg, reg/m64
        /// <param name="crc"></param>
        /// <param name="v"></param>
        /// </summary>
        [KalkExport("mm_crc32_u64", Category)]
        public ulong mm_crc32_u64(ulong crc, ulong v) => (ulong)ProcessFunc<ulong, ulong, ulong, ulong, ulong, ulong>(crc, v, System.Runtime.Intrinsics.X86.Sse42.X64.Crc32);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class SseX64IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSE";

        /// <summary>
        /// Convert the 64-bit integer "b" to a single-precision (32-bit) floating-point element, store the result in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".
        ///
        ///__m128 _mm_cvtsi64_ss (__m128 a, __int64 b)
        ///CVTSI2SS xmm, reg/m64
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_cvtsi64_ss", Category)]
        public object mm_cvtsi64_ss(object a, long b) => (object)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, long, long, float, System.Runtime.Intrinsics.Vector128<float>>(a, b, System.Runtime.Intrinsics.X86.Sse.X64.ConvertScalarToVector128Single);
        
        /// <summary>
        /// Convert the lower single-precision (32-bit) floating-point element in "a" to a 64-bit integer, and store the result in "dst".
        ///
        ///__int64 _mm_cvtss_si64 (__m128 a)
        ///CVTSS2SI r64, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvtss_si64", Category)]
        public long mm_cvtss_si64(object a) => (long)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, long, long>(a, System.Runtime.Intrinsics.X86.Sse.X64.ConvertToInt64);
        
        /// <summary>
        /// Convert the lower single-precision (32-bit) floating-point element in "a" to a 64-bit integer with truncation, and store the result in "dst".
        ///
        ///__int64 _mm_cvttss_si64 (__m128 a)
        ///CVTTSS2SI r64, xmm/m32
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_cvttss_si64", Category)]
        public long mm_cvttss_si64(object a) => (long)ProcessFunc<float, System.Runtime.Intrinsics.Vector128<float>, long, long>(a, System.Runtime.Intrinsics.X86.Sse.X64.ConvertToInt64WithTruncation);
        
    }
}
namespace Kalk.Core.Modules.HardwareIntrinsics.X86
{
    public partial class Ssse3IntrinsicsModule
    {
        public const string Category = "Vector Hardware Intrinsics X86 / SSSE3";

        /// <summary>
        /// Compute the absolute value of packed 16-bit integers in "a", and store the unsigned results in "dst".
        ///
        ///__m128i _mm_abs_epi16 (__m128i a)
        ///PABSW xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_abs_epi16", Category)]
        public object mm_abs_epi16(object a) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, ushort, System.Runtime.Intrinsics.Vector128<ushort>>(a, System.Runtime.Intrinsics.X86.Ssse3.Abs);
        
        /// <summary>
        /// Compute the absolute value of packed 32-bit integers in "a", and store the unsigned results in "dst".
        ///
        ///__m128i _mm_abs_epi32 (__m128i a)
        ///PABSD xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_abs_epi32", Category)]
        public object mm_abs_epi32(object a) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, uint, System.Runtime.Intrinsics.Vector128<uint>>(a, System.Runtime.Intrinsics.X86.Ssse3.Abs);
        
        /// <summary>
        /// Compute the absolute value of packed 8-bit integers in "a", and store the unsigned results in "dst".
        ///
        ///__m128i _mm_abs_epi8 (__m128i a)
        ///PABSB xmm, xmm/m128
        /// <param name="a"></param>
        /// </summary>
        [KalkExport("mm_abs_epi8", Category)]
        public object mm_abs_epi8(object a) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, System.Runtime.Intrinsics.X86.Ssse3.Abs);
        
        /// <summary>
        /// Concatenate 16-byte blocks in "a" and "b" into a 32-byte temporary result, shift the result right by "count" bytes, and store the low 16 bytes in "dst".
        ///
        ///__m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
        ///PALIGNR xmm, xmm/m128, imm8
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="count"></param>
        /// </summary>
        [KalkExport("mm_alignr_epi8", Category)]
        public object mm_alignr_epi8(object a, object b, byte count) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, byte, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, count, System.Runtime.Intrinsics.X86.Ssse3.AlignRight);
        
        /// <summary>
        /// Horizontally add adjacent pairs of 16-bit integers in "a" and "b", and pack the signed 16-bit results in "dst".
        ///
        ///__m128i _mm_hadd_epi16 (__m128i a, __m128i b)
        ///PHADDW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hadd_epi16", Category)]
        public object mm_hadd_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.HorizontalAdd);
        
        /// <summary>
        /// Horizontally add adjacent pairs of 32-bit integers in "a" and "b", and pack the signed 32-bit results in "dst".
        ///
        ///__m128i _mm_hadd_epi32 (__m128i a, __m128i b)
        ///PHADDD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hadd_epi32", Category)]
        public object mm_hadd_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.HorizontalAdd);
        
        /// <summary>
        /// Horizontally add adjacent pairs of 16-bit integers in "a" and "b" using saturation, and pack the signed 16-bit results in "dst".
        ///
        ///__m128i _mm_hadds_epi16 (__m128i a, __m128i b)
        ///PHADDSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hadds_epi16", Category)]
        public object mm_hadds_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.HorizontalAddSaturate);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of 16-bit integers in "a" and "b", and pack the signed 16-bit results in "dst".
        ///
        ///__m128i _mm_hsub_epi16 (__m128i a, __m128i b)
        ///PHSUBW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hsub_epi16", Category)]
        public object mm_hsub_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.HorizontalSubtract);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of 32-bit integers in "a" and "b", and pack the signed 32-bit results in "dst".
        ///
        ///__m128i _mm_hsub_epi32 (__m128i a, __m128i b)
        ///PHSUBD xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hsub_epi32", Category)]
        public object mm_hsub_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.HorizontalSubtract);
        
        /// <summary>
        /// Horizontally subtract adjacent pairs of 16-bit integers in "a" and "b" using saturation, and pack the signed 16-bit results in "dst".
        ///
        ///__m128i _mm_hsubs_epi16 (__m128i a, __m128i b)
        ///PHSUBSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_hsubs_epi16", Category)]
        public object mm_hsubs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.HorizontalSubtractSaturate);
        
        /// <summary>
        /// Vertically multiply each unsigned 8-bit integer from "a" with the corresponding signed 8-bit integer from "b", producing intermediate signed 16-bit integers. Horizontally add adjacent pairs of intermediate signed 16-bit integers, and pack the saturated results in "dst".
        ///
        ///__m128i _mm_maddubs_epi16 (__m128i a, __m128i b)
        ///PMADDUBSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_maddubs_epi16", Category)]
        public object mm_maddubs_epi16(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.MultiplyAddAdjacent);
        
        /// <summary>
        /// Multiply packed 16-bit integers in "a" and "b", producing intermediate signed 32-bit integers. Truncate each intermediate integer to the 18 most significant bits, round by adding 1, and store bits [16:1] to "dst".
        ///
        ///__m128i _mm_mulhrs_epi16 (__m128i a, __m128i b)
        ///PMULHRSW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_mulhrs_epi16", Category)]
        public object mm_mulhrs_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.MultiplyHighRoundScale);
        
        /// <summary>
        /// Shuffle packed 8-bit integers in "a" according to shuffle control mask in the corresponding 8-bit element of "b", and store the results in "dst".
        ///
        ///__m128i _mm_shuffle_epi8 (__m128i a, __m128i b)
        ///PSHUFB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_shuffle_epi8", Category)]
        public object mm_shuffle_epi8(object a, object b) => (object)ProcessFunc<byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>, byte, System.Runtime.Intrinsics.Vector128<byte>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.Shuffle);
        
        /// <summary>
        /// Negate packed 16-bit integers in "a" when the corresponding signed 16-bit integer in "b" is negative, and store the results in "dst". Element in "dst" are zeroed out when the corresponding element in "b" is zero.
        ///
        ///__m128i _mm_sign_epi16 (__m128i a, __m128i b)
        ///PSIGNW xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sign_epi16", Category)]
        public object mm_sign_epi16(object a, object b) => (object)ProcessFunc<short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>, short, System.Runtime.Intrinsics.Vector128<short>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.Sign);
        
        /// <summary>
        /// Negate packed 32-bit integers in "a" when the corresponding signed 32-bit integer in "b" is negative, and store the results in "dst". Element in "dst" are zeroed out when the corresponding element in "b" is zero.
        ///
        ///__m128i _mm_sign_epi32 (__m128i a, __m128i b)
        ///PSIGND xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sign_epi32", Category)]
        public object mm_sign_epi32(object a, object b) => (object)ProcessFunc<int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>, int, System.Runtime.Intrinsics.Vector128<int>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.Sign);
        
        /// <summary>
        /// Negate packed 8-bit integers in "a" when the corresponding signed 8-bit integer in "b" is negative, and store the results in "dst". Element in "dst" are zeroed out when the corresponding element in "b" is zero.
        ///
        ///__m128i _mm_sign_epi8 (__m128i a, __m128i b)
        ///PSIGNB xmm, xmm/m128
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// </summary>
        [KalkExport("mm_sign_epi8", Category)]
        public object mm_sign_epi8(object a, object b) => (object)ProcessFunc<sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>, sbyte, System.Runtime.Intrinsics.Vector128<sbyte>>(a, b, System.Runtime.Intrinsics.X86.Ssse3.Sign);
        
    }
}