[API Proposal]: Arm64: FEAT_SVE: bit manipulation

[a74nh]

namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: bitmanipulate
{

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateSeries(T base, T step); // INDEX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> DuplicateSelectedScalarToVector(T value); // DUP or FDUP or DUPM or CPY or FCPY // predicated, MOVPRFX

  /// T: float, int, uint
  public static unsafe Vector<T> DuplicateSelectedScalarToVector(Vector<T> data, uint index); // DUP or TBL

  /// T: double, long, ulong, float, sbyte, short, int, byte, ushort, uint
  public static unsafe Vector<T> DuplicateSelectedScalarToVector(Vector<T> data, ulong index); // DUP or TBL

  /// T: sbyte, byte
  public static unsafe Vector<T> DuplicateSelectedScalarToVector(Vector<T> data, byte index); // DUP or TBL

  /// T: short, ushort
  public static unsafe Vector<T> DuplicateSelectedScalarToVector(Vector<T> data, ushort index); // DUP or TBL

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ReverseBits(Vector<T> value); // RBIT // predicated, MOVPRFX

  /// T: short, int, long, ushort, uint, ulong
  public static unsafe Vector<T> ReverseBytesWithinElements(Vector<T> value); // REVB // predicated, MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ReverseElement(Vector<T> value); // REV

  /// T: int, long, uint, ulong
  public static unsafe Vector<T> ReverseInt16WithinElements(Vector<T> value); // REVH // predicated, MOVPRFX

  /// T: long, ulong
  public static unsafe Vector<T> ReverseInt32WithinElements(Vector<T> value); // REVW // predicated, MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> Splice(Vector<T> mask, Vector<T> left, Vector<T> right); // SPLICE // MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> TransposeEven(Vector<T> left, Vector<T> right); // TRN1

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> TransposeOdd(Vector<T> left, Vector<T> right); // TRN2

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> UnzipEven(Vector<T> left, Vector<T> right); // UZP1

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> UnzipOdd(Vector<T> left, Vector<T> right); // UZP2

  /// T: [float, uint], [double, ulong], [sbyte, byte], [short, ushort], [int, uint], [long, ulong]
  public static unsafe Vector<T> VectorTableLookup(Vector<T> data, Vector<T2> indices); // TBL

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> VectorTableLookup(Vector<T> data, Vector<T> indices); // TBL

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ZipHigh(Vector<T> left, Vector<T> right); // ZIP2

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ZipLow(Vector<T> left, Vector<T> right); // ZIP1

  /// total method signatures: 20

}

Splice

Splice two vectors under predicate control
Select a region from left and copy it to the lowest-numbered elements of the result. Then set any remaining elements of the result to a copy of the lowest-numbered elements from right. The region is selected using the first and last true elements in mask.

Tagging subscribers to this area: @dotnet/area-system-numerics
See info in area-owners.md if you want to be subscribed.

Issue Details

---

namespace System.Runtime.Intrinsics.Arm

/// VectorT Summary
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE Category: bitmanipulate
{
/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector DuplicateToVector(T value); // DUP or FDUP or DUPM or CPY or FCPY (MOVPRFX)

/// T: float, int, uint
public static unsafe Vector DuplicateToVector(Vector data, uint index); // DUP or TBL

/// T: double, long, ulong, float, sbyte, short, int, byte, ushort, uint
public static unsafe Vector DuplicateToVector(Vector data, ulong index); // DUP or TBL

/// T: sbyte, byte
public static unsafe Vector DuplicateToVector(Vector data, byte index); // DUP or TBL

/// T: short, ushort
public static unsafe Vector DuplicateToVector(Vector data, ushort index); // DUP or TBL

/// T: sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector Index(T base, T step); // INDEX

/// T: sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector Move(Vector value); // AND

/// T: sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector ReverseBits(Vector value); // RBIT (MOVPRFX)

/// T: short, int, long, ushort, uint, ulong
public static unsafe Vector ReverseBytesWithinElements(Vector value); // REVB (MOVPRFX)

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector ReverseElement(Vector value); // REV

/// T: int, long, uint, ulong
public static unsafe Vector ReverseHalfwordsWithinElements(Vector value); // REVH (MOVPRFX)

/// T: long, ulong
public static unsafe Vector ReverseWordsWithinElements(Vector value); // REVW (MOVPRFX)

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector Splice(Vector left, Vector right); // SPLICE (MOVPRFX)

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector TransposeEven(Vector left, Vector right); // TRN1

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector TransposeOdd(Vector left, Vector right); // TRN2

/// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
public static unsafe Vector UnpackWidenLower(Vector value); // SUNPKLO or UUNPKLO

/// T: sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector UnpackWidenLower(Vector value); // PUNPKLO

/// T: [short, sbyte], [int, short], [long, int], [ushort, byte], [uint, ushort], [ulong, uint]
public static unsafe Vector UnpackWidenUpper(Vector value); // SUNPKHI or UUNPKHI

/// T: sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector UnpackWidenUpper(Vector value); // PUNPKHI

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector UnzipEven(Vector left, Vector right); // UZP1

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector UnzipOdd(Vector left, Vector right); // UZP2

/// T: [float, uint], [double, ulong], [sbyte, byte], [short, ushort], [int, uint], [long, ulong]
public static unsafe Vector VectorTableLookup(Vector data, Vector indices); // TBL

/// T: byte, ushort, uint, ulong
public static unsafe Vector VectorTableLookup(Vector data, Vector indices); // TBL

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector ZipHigh(Vector left, Vector right); // ZIP2

/// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
public static unsafe Vector ZipLow(Vector left, Vector right); // ZIP1

/// total method signatures: 25
}

Author:	a74nh
Assignees:	-
Labels:	area-System.Numerics
Milestone:	-

[a74nh]

/// Full API
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: bitmanipulate
{
    /// CreateSeries : Create linear series

    /// svint8_t svindex_s8(int8_t base, int8_t step) : "INDEX Zresult.B, #base, #step" or "INDEX Zresult.B, #base, Wstep" or "INDEX Zresult.B, Wbase, #step" or "INDEX Zresult.B, Wbase, Wstep"
  public static unsafe Vector<sbyte> CreateSeries(sbyte base, sbyte step);

    /// svint16_t svindex_s16(int16_t base, int16_t step) : "INDEX Zresult.H, #base, #step" or "INDEX Zresult.H, #base, Wstep" or "INDEX Zresult.H, Wbase, #step" or "INDEX Zresult.H, Wbase, Wstep"
  public static unsafe Vector<short> CreateSeries(short base, short step);

    /// svint32_t svindex_s32(int32_t base, int32_t step) : "INDEX Zresult.S, #base, #step" or "INDEX Zresult.S, #base, Wstep" or "INDEX Zresult.S, Wbase, #step" or "INDEX Zresult.S, Wbase, Wstep"
  public static unsafe Vector<int> CreateSeries(int base, int step);

    /// svint64_t svindex_s64(int64_t base, int64_t step) : "INDEX Zresult.D, #base, #step" or "INDEX Zresult.D, #base, Xstep" or "INDEX Zresult.D, Xbase, #step" or "INDEX Zresult.D, Xbase, Xstep"
  public static unsafe Vector<long> CreateSeries(long base, long step);

    /// svuint8_t svindex_u8(uint8_t base, uint8_t step) : "INDEX Zresult.B, #base, #step" or "INDEX Zresult.B, #base, Wstep" or "INDEX Zresult.B, Wbase, #step" or "INDEX Zresult.B, Wbase, Wstep"
  public static unsafe Vector<byte> CreateSeries(byte base, byte step);

    /// svuint16_t svindex_u16(uint16_t base, uint16_t step) : "INDEX Zresult.H, #base, #step" or "INDEX Zresult.H, #base, Wstep" or "INDEX Zresult.H, Wbase, #step" or "INDEX Zresult.H, Wbase, Wstep"
  public static unsafe Vector<ushort> CreateSeries(ushort base, ushort step);

    /// svuint32_t svindex_u32(uint32_t base, uint32_t step) : "INDEX Zresult.S, #base, #step" or "INDEX Zresult.S, #base, Wstep" or "INDEX Zresult.S, Wbase, #step" or "INDEX Zresult.S, Wbase, Wstep"
  public static unsafe Vector<uint> CreateSeries(uint base, uint step);

    /// svuint64_t svindex_u64(uint64_t base, uint64_t step) : "INDEX Zresult.D, #base, #step" or "INDEX Zresult.D, #base, Xstep" or "INDEX Zresult.D, Xbase, #step" or "INDEX Zresult.D, Xbase, Xstep"
  public static unsafe Vector<ulong> CreateSeries(ulong base, ulong step);


    /// DuplicateSelectedScalarToVector : Broadcast a scalar value

    /// svfloat32_t svdup[_n]_f32(float32_t op) : "DUP Zresult.S, #op" or "FDUP Zresult.S, #op" or "DUP Zresult.S, Wop" or "DUP Zresult.S, Zop.S[0]"
    /// svfloat32_t svdup[_n]_f32_m(svfloat32_t inactive, svbool_t pg, float32_t op) : "CPY Ztied.S, Pg/M, #bitcast<int32_t>(op)" or "FCPY Ztied.S, Pg/M, #op" or "CPY Ztied.S, Pg/M, Wop" or "CPY Ztied.S, Pg/M, Sop"
    /// svfloat32_t svdup[_n]_f32_x(svbool_t pg, float32_t op) : "CPY Zresult.S, Pg/Z, #bitcast<int32_t>(op)" or "DUP Zresult.S, #op" or "FCPY Zresult.S, Pg/M, #op" or "FDUP Zresult.S, #op" or "DUP Zresult.S, Wop" or "DUP Zresult.S, Zop.S[0]"
    /// svfloat32_t svdup[_n]_f32_z(svbool_t pg, float32_t op) : "CPY Zresult.S, Pg/Z, #bitcast<int32_t>(op)" or "DUP Zresult.S, #0; FCPY Zresult.S, Pg/M, #op" or "DUP Zresult.S, #0; CPY Zresult.S, Pg/M, Wop" or "MOVPRFX Zresult.S, Pg/Z, Zop.S; CPY Zresult.S, Pg/M, Sop"
  public static unsafe Vector<float> DuplicateSelectedScalarToVector(float value);

    /// svfloat64_t svdup[_n]_f64(float64_t op) : "DUP Zresult.D, #op" or "FDUP Zresult.D, #op" or "DUP Zresult.D, Xop" or "DUP Zresult.D, Zop.D[0]"
    /// svfloat64_t svdup[_n]_f64_m(svfloat64_t inactive, svbool_t pg, float64_t op) : "CPY Ztied.D, Pg/M, #bitcast<int64_t>(op)" or "FCPY Ztied.D, Pg/M, #op" or "CPY Ztied.D, Pg/M, Xop" or "CPY Ztied.D, Pg/M, Dop"
    /// svfloat64_t svdup[_n]_f64_x(svbool_t pg, float64_t op) : "CPY Zresult.D, Pg/Z, #bitcast<int64_t>(op)" or "DUP Zresult.D, #op" or "FCPY Zresult.D, Pg/M, #op" or "FDUP Zresult.D, #op" or "DUP Zresult.D, Xop" or "DUP Zresult.D, Zop.D[0]"
    /// svfloat64_t svdup[_n]_f64_z(svbool_t pg, float64_t op) : "CPY Zresult.D, Pg/Z, #bitcast<int64_t>(op)" or "DUP Zresult.D, #0; FCPY Zresult.D, Pg/M, #op" or "DUP Zresult.D, #0; CPY Zresult.D, Pg/M, Xop" or "MOVPRFX Zresult.D, Pg/Z, Zop.D; CPY Zresult.D, Pg/M, Dop"
  public static unsafe Vector<double> DuplicateSelectedScalarToVector(double value);

    /// svint8_t svdup[_n]_s8(int8_t op) : "DUP Zresult.B, #op" or "FDUP Zresult.B, #op" or "DUPM Zresult.B, #op" or "DUP Zresult.B, Wop" or "DUP Zresult.B, Zop.B[0]"
    /// svint8_t svdup[_n]_s8_m(svint8_t inactive, svbool_t pg, int8_t op) : "CPY Ztied.B, Pg/M, #op" or "FCPY Ztied.B, Pg/M, #op" or "CPY Ztied.B, Pg/M, Wop" or "CPY Ztied.B, Pg/M, Bop"
    /// svint8_t svdup[_n]_s8_x(svbool_t pg, int8_t op) : "CPY Zresult.B, Pg/Z, #op" or "DUP Zresult.B, #op" or "FCPY Zresult.B, Pg/M, #op" or "FDUP Zresult.B, #op" or "DUPM Zresult.B, #op" or "DUP Zresult.B, Wop" or "DUP Zresult.B, Zop.B[0]"
    /// svint8_t svdup[_n]_s8_z(svbool_t pg, int8_t op) : "CPY Zresult.B, Pg/Z, #op" or "DUP Zresult.B, #0; FCPY Zresult.B, Pg/M, #op" or "DUP Zresult.B, #0; CPY Zresult.B, Pg/M, Wop" or "MOVPRFX Zresult.B, Pg/Z, Zop.B; CPY Zresult.B, Pg/M, Bop"
  public static unsafe Vector<sbyte> DuplicateSelectedScalarToVector(sbyte value);

    /// svint16_t svdup[_n]_s16(int16_t op) : "DUP Zresult.H, #op" or "FDUP Zresult.H, #op" or "DUPM Zresult.H, #op" or "DUP Zresult.H, Wop" or "DUP Zresult.H, Zop.H[0]"
    /// svint16_t svdup[_n]_s16_m(svint16_t inactive, svbool_t pg, int16_t op) : "CPY Ztied.H, Pg/M, #op" or "FCPY Ztied.H, Pg/M, #op" or "CPY Ztied.H, Pg/M, Wop" or "CPY Ztied.H, Pg/M, Hop"
    /// svint16_t svdup[_n]_s16_x(svbool_t pg, int16_t op) : "CPY Zresult.H, Pg/Z, #op" or "DUP Zresult.H, #op" or "FCPY Zresult.H, Pg/M, #op" or "FDUP Zresult.H, #op" or "DUPM Zresult.H, #op" or "DUP Zresult.H, Wop" or "DUP Zresult.H, Zop.H[0]"
    /// svint16_t svdup[_n]_s16_z(svbool_t pg, int16_t op) : "CPY Zresult.H, Pg/Z, #op" or "DUP Zresult.H, #0; FCPY Zresult.H, Pg/M, #op" or "DUP Zresult.H, #0; CPY Zresult.H, Pg/M, Wop" or "MOVPRFX Zresult.H, Pg/Z, Zop.H; CPY Zresult.H, Pg/M, Hop"
  public static unsafe Vector<short> DuplicateSelectedScalarToVector(short value);

    /// svint32_t svdup[_n]_s32(int32_t op) : "DUP Zresult.S, #op" or "FDUP Zresult.S, #op" or "DUPM Zresult.S, #op" or "DUP Zresult.S, Wop" or "DUP Zresult.S, Zop.S[0]"
    /// svint32_t svdup[_n]_s32_m(svint32_t inactive, svbool_t pg, int32_t op) : "CPY Ztied.S, Pg/M, #op" or "FCPY Ztied.S, Pg/M, #op" or "CPY Ztied.S, Pg/M, Wop" or "CPY Ztied.S, Pg/M, Sop"
    /// svint32_t svdup[_n]_s32_x(svbool_t pg, int32_t op) : "CPY Zresult.S, Pg/Z, #op" or "DUP Zresult.S, #op" or "FCPY Zresult.S, Pg/M, #op" or "FDUP Zresult.S, #op" or "DUPM Zresult.S, #op" or "DUP Zresult.S, Wop" or "DUP Zresult.S, Zop.S[0]"
    /// svint32_t svdup[_n]_s32_z(svbool_t pg, int32_t op) : "CPY Zresult.S, Pg/Z, #op" or "DUP Zresult.S, #0; FCPY Zresult.S, Pg/M, #op" or "DUP Zresult.S, #0; CPY Zresult.S, Pg/M, Wop" or "MOVPRFX Zresult.S, Pg/Z, Zop.S; CPY Zresult.S, Pg/M, Sop"
  public static unsafe Vector<int> DuplicateSelectedScalarToVector(int value);

    /// svint64_t svdup[_n]_s64(int64_t op) : "DUP Zresult.D, #op" or "FDUP Zresult.D, #op" or "DUPM Zresult.D, #op" or "DUP Zresult.D, Xop" or "DUP Zresult.D, Zop.D[0]"
    /// svint64_t svdup[_n]_s64_m(svint64_t inactive, svbool_t pg, int64_t op) : "CPY Ztied.D, Pg/M, #op" or "FCPY Ztied.D, Pg/M, #op" or "CPY Ztied.D, Pg/M, Xop" or "CPY Ztied.D, Pg/M, Dop"
    /// svint64_t svdup[_n]_s64_x(svbool_t pg, int64_t op) : "CPY Zresult.D, Pg/Z, #op" or "DUP Zresult.D, #op" or "FCPY Zresult.D, Pg/M, #op" or "FDUP Zresult.D, #op" or "DUPM Zresult.D, #op" or "DUP Zresult.D, Xop" or "DUP Zresult.D, Zop.D[0]"
    /// svint64_t svdup[_n]_s64_z(svbool_t pg, int64_t op) : "CPY Zresult.D, Pg/Z, #op" or "DUP Zresult.D, #0; FCPY Zresult.D, Pg/M, #op" or "DUP Zresult.D, #0; CPY Zresult.D, Pg/M, Xop" or "MOVPRFX Zresult.D, Pg/Z, Zop.D; CPY Zresult.D, Pg/M, Dop"
  public static unsafe Vector<long> DuplicateSelectedScalarToVector(long value);

    /// svuint8_t svdup[_n]_u8(uint8_t op) : "DUP Zresult.B, #op" or "FDUP Zresult.B, #op" or "DUPM Zresult.B, #op" or "DUP Zresult.B, Wop" or "DUP Zresult.B, Zop.B[0]"
    /// svuint8_t svdup[_n]_u8_m(svuint8_t inactive, svbool_t pg, uint8_t op) : "CPY Ztied.B, Pg/M, #(int8_t)op" or "FCPY Ztied.B, Pg/M, #op" or "CPY Ztied.B, Pg/M, Wop" or "CPY Ztied.B, Pg/M, Bop"
    /// svuint8_t svdup[_n]_u8_x(svbool_t pg, uint8_t op) : "CPY Zresult.B, Pg/Z, #(int8_t)op" or "DUP Zresult.B, #op" or "FCPY Zresult.B, Pg/M, #op" or "FDUP Zresult.B, #op" or "DUPM Zresult.B, #op" or "DUP Zresult.B, Wop" or "DUP Zresult.B, Zop.B[0]"
    /// svuint8_t svdup[_n]_u8_z(svbool_t pg, uint8_t op) : "CPY Zresult.B, Pg/Z, #(int8_t)op" or "DUP Zresult.B, #0; FCPY Zresult.B, Pg/M, #op" or "DUP Zresult.B, #0; CPY Zresult.B, Pg/M, Wop" or "MOVPRFX Zresult.B, Pg/Z, Zop.B; CPY Zresult.B, Pg/M, Bop"
  public static unsafe Vector<byte> DuplicateSelectedScalarToVector(byte value);

    /// svuint16_t svdup[_n]_u16(uint16_t op) : "DUP Zresult.H, #op" or "FDUP Zresult.H, #op" or "DUPM Zresult.H, #op" or "DUP Zresult.H, Wop" or "DUP Zresult.H, Zop.H[0]"
    /// svuint16_t svdup[_n]_u16_m(svuint16_t inactive, svbool_t pg, uint16_t op) : "CPY Ztied.H, Pg/M, #(int16_t)op" or "FCPY Ztied.H, Pg/M, #op" or "CPY Ztied.H, Pg/M, Wop" or "CPY Ztied.H, Pg/M, Hop"
    /// svuint16_t svdup[_n]_u16_x(svbool_t pg, uint16_t op) : "CPY Zresult.H, Pg/Z, #(int16_t)op" or "DUP Zresult.H, #op" or "FCPY Zresult.H, Pg/M, #op" or "FDUP Zresult.H, #op" or "DUPM Zresult.H, #op" or "DUP Zresult.H, Wop" or "DUP Zresult.H, Zop.H[0]"
    /// svuint16_t svdup[_n]_u16_z(svbool_t pg, uint16_t op) : "CPY Zresult.H, Pg/Z, #(int16_t)op" or "DUP Zresult.H, #0; FCPY Zresult.H, Pg/M, #op" or "DUP Zresult.H, #0; CPY Zresult.H, Pg/M, Wop" or "MOVPRFX Zresult.H, Pg/Z, Zop.H; CPY Zresult.H, Pg/M, Hop"
  public static unsafe Vector<ushort> DuplicateSelectedScalarToVector(ushort value);

    /// svuint32_t svdup[_n]_u32(uint32_t op) : "DUP Zresult.S, #op" or "FDUP Zresult.S, #op" or "DUPM Zresult.S, #op" or "DUP Zresult.S, Wop" or "DUP Zresult.S, Zop.S[0]"
    /// svuint32_t svdup[_n]_u32_m(svuint32_t inactive, svbool_t pg, uint32_t op) : "CPY Ztied.S, Pg/M, #(int32_t)op" or "FCPY Ztied.S, Pg/M, #op" or "CPY Ztied.S, Pg/M, Wop" or "CPY Ztied.S, Pg/M, Sop"
    /// svuint32_t svdup[_n]_u32_x(svbool_t pg, uint32_t op) : "CPY Zresult.S, Pg/Z, #(int32_t)op" or "DUP Zresult.S, #op" or "FCPY Zresult.S, Pg/M, #op" or "FDUP Zresult.S, #op" or "DUPM Zresult.S, #op" or "DUP Zresult.S, Wop" or "DUP Zresult.S, Zop.S[0]"
    /// svuint32_t svdup[_n]_u32_z(svbool_t pg, uint32_t op) : "CPY Zresult.S, Pg/Z, #(int32_t)op" or "DUP Zresult.S, #0; FCPY Zresult.S, Pg/M, #op" or "DUP Zresult.S, #0; CPY Zresult.S, Pg/M, Wop" or "MOVPRFX Zresult.S, Pg/Z, Zop.S; CPY Zresult.S, Pg/M, Sop"
  public static unsafe Vector<uint> DuplicateSelectedScalarToVector(uint value);

    /// svuint64_t svdup[_n]_u64(uint64_t op) : "DUP Zresult.D, #op" or "FDUP Zresult.D, #op" or "DUPM Zresult.D, #op" or "DUP Zresult.D, Xop" or "DUP Zresult.D, Zop.D[0]"
    /// svuint64_t svdup[_n]_u64_m(svuint64_t inactive, svbool_t pg, uint64_t op) : "CPY Ztied.D, Pg/M, #(int64_t)op" or "FCPY Ztied.D, Pg/M, #op" or "CPY Ztied.D, Pg/M, Xop" or "CPY Ztied.D, Pg/M, Dop"
    /// svuint64_t svdup[_n]_u64_x(svbool_t pg, uint64_t op) : "CPY Zresult.D, Pg/Z, #(int64_t)op" or "DUP Zresult.D, #op" or "FCPY Zresult.D, Pg/M, #op" or "FDUP Zresult.D, #op" or "DUPM Zresult.D, #op" or "DUP Zresult.D, Xop" or "DUP Zresult.D, Zop.D[0]"
    /// svuint64_t svdup[_n]_u64_z(svbool_t pg, uint64_t op) : "CPY Zresult.D, Pg/Z, #(int64_t)op" or "DUP Zresult.D, #0; FCPY Zresult.D, Pg/M, #op" or "DUP Zresult.D, #0; CPY Zresult.D, Pg/M, Xop" or "MOVPRFX Zresult.D, Pg/Z, Zop.D; CPY Zresult.D, Pg/M, Dop"
  public static unsafe Vector<ulong> DuplicateSelectedScalarToVector(ulong value);

    /// svfloat32_t svdup_lane[_f32](svfloat32_t data, uint32_t index) : "DUP Zresult.S, Zdata.S[index]" or "TBL Zresult.S, Zdata.S, Zindex.S"
  public static unsafe Vector<float> DuplicateSelectedScalarToVector(Vector<float> data, uint index);

    /// svfloat64_t svdup_lane[_f64](svfloat64_t data, uint64_t index) : "DUP Zresult.D, Zdata.D[index]" or "TBL Zresult.D, Zdata.D, Zindex.D"
    /// svfloat64_t svdupq_lane[_f64](svfloat64_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<double> DuplicateSelectedScalarToVector(Vector<double> data, ulong index);

    /// svint8_t svdup_lane[_s8](svint8_t data, uint8_t index) : "DUP Zresult.B, Zdata.B[index]" or "TBL Zresult.B, Zdata.B, Zindex.B"
  public static unsafe Vector<sbyte> DuplicateSelectedScalarToVector(Vector<sbyte> data, byte index);

    /// svint16_t svdup_lane[_s16](svint16_t data, uint16_t index) : "DUP Zresult.H, Zdata.H[index]" or "TBL Zresult.H, Zdata.H, Zindex.H"
  public static unsafe Vector<short> DuplicateSelectedScalarToVector(Vector<short> data, ushort index);

    /// svint32_t svdup_lane[_s32](svint32_t data, uint32_t index) : "DUP Zresult.S, Zdata.S[index]" or "TBL Zresult.S, Zdata.S, Zindex.S"
  public static unsafe Vector<int> DuplicateSelectedScalarToVector(Vector<int> data, uint index);

    /// svint64_t svdup_lane[_s64](svint64_t data, uint64_t index) : "DUP Zresult.D, Zdata.D[index]" or "TBL Zresult.D, Zdata.D, Zindex.D"
    /// svint64_t svdupq_lane[_s64](svint64_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<long> DuplicateSelectedScalarToVector(Vector<long> data, ulong index);

    /// svuint8_t svdup_lane[_u8](svuint8_t data, uint8_t index) : "DUP Zresult.B, Zdata.B[index]" or "TBL Zresult.B, Zdata.B, Zindex.B"
  public static unsafe Vector<byte> DuplicateSelectedScalarToVector(Vector<byte> data, byte index);

    /// svuint16_t svdup_lane[_u16](svuint16_t data, uint16_t index) : "DUP Zresult.H, Zdata.H[index]" or "TBL Zresult.H, Zdata.H, Zindex.H"
  public static unsafe Vector<ushort> DuplicateSelectedScalarToVector(Vector<ushort> data, ushort index);

    /// svuint32_t svdup_lane[_u32](svuint32_t data, uint32_t index) : "DUP Zresult.S, Zdata.S[index]" or "TBL Zresult.S, Zdata.S, Zindex.S"
  public static unsafe Vector<uint> DuplicateSelectedScalarToVector(Vector<uint> data, uint index);

    /// svuint64_t svdup_lane[_u64](svuint64_t data, uint64_t index) : "DUP Zresult.D, Zdata.D[index]" or "TBL Zresult.D, Zdata.D, Zindex.D"
    /// svuint64_t svdupq_lane[_u64](svuint64_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<ulong> DuplicateSelectedScalarToVector(Vector<ulong> data, ulong index);

    /// svfloat32_t svdupq_lane[_f32](svfloat32_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<float> DuplicateSelectedScalarToVector(Vector<float> data, ulong index);

    /// svint8_t svdupq_lane[_s8](svint8_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<sbyte> DuplicateSelectedScalarToVector(Vector<sbyte> data, ulong index);

    /// svint16_t svdupq_lane[_s16](svint16_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<short> DuplicateSelectedScalarToVector(Vector<short> data, ulong index);

    /// svint32_t svdupq_lane[_s32](svint32_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<int> DuplicateSelectedScalarToVector(Vector<int> data, ulong index);

    /// svuint8_t svdupq_lane[_u8](svuint8_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<byte> DuplicateSelectedScalarToVector(Vector<byte> data, ulong index);

    /// svuint16_t svdupq_lane[_u16](svuint16_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<ushort> DuplicateSelectedScalarToVector(Vector<ushort> data, ulong index);

    /// svuint32_t svdupq_lane[_u32](svuint32_t data, uint64_t index) : "DUP Zresult.Q, Zdata.Q[index]" or "TBL Zresult.D, Zdata.D, Zindices_d.D"
  public static unsafe Vector<uint> DuplicateSelectedScalarToVector(Vector<uint> data, ulong index);


    /// ReverseBits : Reverse bits

    /// svint8_t svrbit[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) : "RBIT Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.B, Pg/M, Zop.B"
    /// svint8_t svrbit[_s8]_x(svbool_t pg, svint8_t op) : "RBIT Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; RBIT Zresult.B, Pg/M, Zop.B"
    /// svint8_t svrbit[_s8]_z(svbool_t pg, svint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; RBIT Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<sbyte> ReverseBits(Vector<sbyte> value);

    /// svint16_t svrbit[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) : "RBIT Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.H, Pg/M, Zop.H"
    /// svint16_t svrbit[_s16]_x(svbool_t pg, svint16_t op) : "RBIT Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; RBIT Zresult.H, Pg/M, Zop.H"
    /// svint16_t svrbit[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; RBIT Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<short> ReverseBits(Vector<short> value);

    /// svint32_t svrbit[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) : "RBIT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.S, Pg/M, Zop.S"
    /// svint32_t svrbit[_s32]_x(svbool_t pg, svint32_t op) : "RBIT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; RBIT Zresult.S, Pg/M, Zop.S"
    /// svint32_t svrbit[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; RBIT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<int> ReverseBits(Vector<int> value);

    /// svint64_t svrbit[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) : "RBIT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrbit[_s64]_x(svbool_t pg, svint64_t op) : "RBIT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; RBIT Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrbit[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; RBIT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<long> ReverseBits(Vector<long> value);

    /// svuint8_t svrbit[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) : "RBIT Ztied.B, Pg/M, Zop.B" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svrbit[_u8]_x(svbool_t pg, svuint8_t op) : "RBIT Ztied.B, Pg/M, Ztied.B" or "MOVPRFX Zresult, Zop; RBIT Zresult.B, Pg/M, Zop.B"
    /// svuint8_t svrbit[_u8]_z(svbool_t pg, svuint8_t op) : "MOVPRFX Zresult.B, Pg/Z, Zop.B; RBIT Zresult.B, Pg/M, Zop.B"
  public static unsafe Vector<byte> ReverseBits(Vector<byte> value);

    /// svuint16_t svrbit[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) : "RBIT Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svrbit[_u16]_x(svbool_t pg, svuint16_t op) : "RBIT Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; RBIT Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svrbit[_u16]_z(svbool_t pg, svuint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; RBIT Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> ReverseBits(Vector<ushort> value);

    /// svuint32_t svrbit[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "RBIT Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svrbit[_u32]_x(svbool_t pg, svuint32_t op) : "RBIT Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; RBIT Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svrbit[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; RBIT Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> ReverseBits(Vector<uint> value);

    /// svuint64_t svrbit[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "RBIT Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; RBIT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrbit[_u64]_x(svbool_t pg, svuint64_t op) : "RBIT Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; RBIT Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrbit[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; RBIT Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> ReverseBits(Vector<ulong> value);


    /// ReverseBytesWithinElements : Reverse bytes within elements

    /// svint16_t svrevb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) : "REVB Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; REVB Zresult.H, Pg/M, Zop.H"
    /// svint16_t svrevb[_s16]_x(svbool_t pg, svint16_t op) : "REVB Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; REVB Zresult.H, Pg/M, Zop.H"
    /// svint16_t svrevb[_s16]_z(svbool_t pg, svint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; REVB Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<short> ReverseBytesWithinElements(Vector<short> value);

    /// svint32_t svrevb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) : "REVB Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; REVB Zresult.S, Pg/M, Zop.S"
    /// svint32_t svrevb[_s32]_x(svbool_t pg, svint32_t op) : "REVB Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; REVB Zresult.S, Pg/M, Zop.S"
    /// svint32_t svrevb[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; REVB Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<int> ReverseBytesWithinElements(Vector<int> value);

    /// svint64_t svrevb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) : "REVB Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; REVB Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrevb[_s64]_x(svbool_t pg, svint64_t op) : "REVB Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; REVB Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrevb[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; REVB Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<long> ReverseBytesWithinElements(Vector<long> value);

    /// svuint16_t svrevb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) : "REVB Ztied.H, Pg/M, Zop.H" or "MOVPRFX Zresult, Zinactive; REVB Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svrevb[_u16]_x(svbool_t pg, svuint16_t op) : "REVB Ztied.H, Pg/M, Ztied.H" or "MOVPRFX Zresult, Zop; REVB Zresult.H, Pg/M, Zop.H"
    /// svuint16_t svrevb[_u16]_z(svbool_t pg, svuint16_t op) : "MOVPRFX Zresult.H, Pg/Z, Zop.H; REVB Zresult.H, Pg/M, Zop.H"
  public static unsafe Vector<ushort> ReverseBytesWithinElements(Vector<ushort> value);

    /// svuint32_t svrevb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "REVB Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; REVB Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svrevb[_u32]_x(svbool_t pg, svuint32_t op) : "REVB Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; REVB Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svrevb[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; REVB Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> ReverseBytesWithinElements(Vector<uint> value);

    /// svuint64_t svrevb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "REVB Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; REVB Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrevb[_u64]_x(svbool_t pg, svuint64_t op) : "REVB Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; REVB Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrevb[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; REVB Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> ReverseBytesWithinElements(Vector<ulong> value);


    /// ReverseElement : Reverse all elements

    /// svfloat32_t svrev[_f32](svfloat32_t op) : "REV Zresult.S, Zop.S"
  public static unsafe Vector<float> ReverseElement(Vector<float> value);

    /// svfloat64_t svrev[_f64](svfloat64_t op) : "REV Zresult.D, Zop.D"
  public static unsafe Vector<double> ReverseElement(Vector<double> value);

    /// svint8_t svrev[_s8](svint8_t op) : "REV Zresult.B, Zop.B"
  public static unsafe Vector<sbyte> ReverseElement(Vector<sbyte> value);

    /// svint16_t svrev[_s16](svint16_t op) : "REV Zresult.H, Zop.H"
  public static unsafe Vector<short> ReverseElement(Vector<short> value);

    /// svint32_t svrev[_s32](svint32_t op) : "REV Zresult.S, Zop.S"
  public static unsafe Vector<int> ReverseElement(Vector<int> value);

    /// svint64_t svrev[_s64](svint64_t op) : "REV Zresult.D, Zop.D"
  public static unsafe Vector<long> ReverseElement(Vector<long> value);

    /// svuint8_t svrev[_u8](svuint8_t op) : "REV Zresult.B, Zop.B"
    /// svbool_t svrev_b8(svbool_t op) : "REV Presult.B, Pop.B"
  public static unsafe Vector<byte> ReverseElement(Vector<byte> value);

    /// svuint16_t svrev[_u16](svuint16_t op) : "REV Zresult.H, Zop.H"
    /// svbool_t svrev_b16(svbool_t op) : "REV Presult.H, Pop.H"
  public static unsafe Vector<ushort> ReverseElement(Vector<ushort> value);

    /// svuint32_t svrev[_u32](svuint32_t op) : "REV Zresult.S, Zop.S"
    /// svbool_t svrev_b32(svbool_t op) : "REV Presult.S, Pop.S"
  public static unsafe Vector<uint> ReverseElement(Vector<uint> value);

    /// svuint64_t svrev[_u64](svuint64_t op) : "REV Zresult.D, Zop.D"
    /// svbool_t svrev_b64(svbool_t op) : "REV Presult.D, Pop.D"
  public static unsafe Vector<ulong> ReverseElement(Vector<ulong> value);


    /// ReverseInt16WithinElements : Reverse halfwords within elements

    /// svint32_t svrevh[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) : "REVH Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; REVH Zresult.S, Pg/M, Zop.S"
    /// svint32_t svrevh[_s32]_x(svbool_t pg, svint32_t op) : "REVH Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; REVH Zresult.S, Pg/M, Zop.S"
    /// svint32_t svrevh[_s32]_z(svbool_t pg, svint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; REVH Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<int> ReverseInt16WithinElements(Vector<int> value);

    /// svint64_t svrevh[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) : "REVH Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; REVH Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrevh[_s64]_x(svbool_t pg, svint64_t op) : "REVH Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; REVH Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrevh[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; REVH Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<long> ReverseInt16WithinElements(Vector<long> value);

    /// svuint32_t svrevh[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) : "REVH Ztied.S, Pg/M, Zop.S" or "MOVPRFX Zresult, Zinactive; REVH Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svrevh[_u32]_x(svbool_t pg, svuint32_t op) : "REVH Ztied.S, Pg/M, Ztied.S" or "MOVPRFX Zresult, Zop; REVH Zresult.S, Pg/M, Zop.S"
    /// svuint32_t svrevh[_u32]_z(svbool_t pg, svuint32_t op) : "MOVPRFX Zresult.S, Pg/Z, Zop.S; REVH Zresult.S, Pg/M, Zop.S"
  public static unsafe Vector<uint> ReverseInt16WithinElements(Vector<uint> value);

    /// svuint64_t svrevh[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "REVH Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; REVH Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrevh[_u64]_x(svbool_t pg, svuint64_t op) : "REVH Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; REVH Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrevh[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; REVH Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> ReverseInt16WithinElements(Vector<ulong> value);


    /// ReverseInt32WithinElements : Reverse words within elements

    /// svint64_t svrevw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) : "REVW Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; REVW Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrevw[_s64]_x(svbool_t pg, svint64_t op) : "REVW Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; REVW Zresult.D, Pg/M, Zop.D"
    /// svint64_t svrevw[_s64]_z(svbool_t pg, svint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; REVW Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<long> ReverseInt32WithinElements(Vector<long> value);

    /// svuint64_t svrevw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) : "REVW Ztied.D, Pg/M, Zop.D" or "MOVPRFX Zresult, Zinactive; REVW Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrevw[_u64]_x(svbool_t pg, svuint64_t op) : "REVW Ztied.D, Pg/M, Ztied.D" or "MOVPRFX Zresult, Zop; REVW Zresult.D, Pg/M, Zop.D"
    /// svuint64_t svrevw[_u64]_z(svbool_t pg, svuint64_t op) : "MOVPRFX Zresult.D, Pg/Z, Zop.D; REVW Zresult.D, Pg/M, Zop.D"
  public static unsafe Vector<ulong> ReverseInt32WithinElements(Vector<ulong> value);


    /// Splice : Splice two vectors under predicate control

    /// svfloat32_t svsplice[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.S, Pg, Zresult.S, Zop2.S"
  public static unsafe Vector<float> Splice(Vector<float> mask, Vector<float> left, Vector<float> right);

    /// svfloat64_t svsplice[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.D, Pg, Zresult.D, Zop2.D"
  public static unsafe Vector<double> Splice(Vector<double> mask, Vector<double> left, Vector<double> right);

    /// svint8_t svsplice[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.B, Pg, Zresult.B, Zop2.B"
  public static unsafe Vector<sbyte> Splice(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svsplice[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.H, Pg, Zresult.H, Zop2.H"
  public static unsafe Vector<short> Splice(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svint32_t svsplice[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.S, Pg, Zresult.S, Zop2.S"
  public static unsafe Vector<int> Splice(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svint64_t svsplice[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.D, Pg, Zresult.D, Zop2.D"
  public static unsafe Vector<long> Splice(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svuint8_t svsplice[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.B, Pg, Zresult.B, Zop2.B"
  public static unsafe Vector<byte> Splice(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svuint16_t svsplice[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.H, Pg, Zresult.H, Zop2.H"
  public static unsafe Vector<ushort> Splice(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svsplice[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.S, Pg, Zresult.S, Zop2.S"
  public static unsafe Vector<uint> Splice(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svuint64_t svsplice[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D" or "MOVPRFX Zresult, Zop1; SPLICE Zresult.D, Pg, Zresult.D, Zop2.D"
  public static unsafe Vector<ulong> Splice(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);


    /// TransposeEven : Interleave even elements from two inputs

    /// svfloat32_t svtrn1[_f32](svfloat32_t op1, svfloat32_t op2) : "TRN1 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<float> TransposeEven(Vector<float> left, Vector<float> right);

    /// svfloat64_t svtrn1[_f64](svfloat64_t op1, svfloat64_t op2) : "TRN1 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<double> TransposeEven(Vector<double> left, Vector<double> right);

    /// svint8_t svtrn1[_s8](svint8_t op1, svint8_t op2) : "TRN1 Zresult.B, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> TransposeEven(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svtrn1[_s16](svint16_t op1, svint16_t op2) : "TRN1 Zresult.H, Zop1.H, Zop2.H"
  public static unsafe Vector<short> TransposeEven(Vector<short> left, Vector<short> right);

    /// svint32_t svtrn1[_s32](svint32_t op1, svint32_t op2) : "TRN1 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<int> TransposeEven(Vector<int> left, Vector<int> right);

    /// svint64_t svtrn1[_s64](svint64_t op1, svint64_t op2) : "TRN1 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<long> TransposeEven(Vector<long> left, Vector<long> right);

    /// svuint8_t svtrn1[_u8](svuint8_t op1, svuint8_t op2) : "TRN1 Zresult.B, Zop1.B, Zop2.B"
    /// svbool_t svtrn1_b8(svbool_t op1, svbool_t op2) : "TRN1 Presult.B, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> TransposeEven(Vector<byte> left, Vector<byte> right);

    /// svuint16_t svtrn1[_u16](svuint16_t op1, svuint16_t op2) : "TRN1 Zresult.H, Zop1.H, Zop2.H"
    /// svbool_t svtrn1_b16(svbool_t op1, svbool_t op2) : "TRN1 Presult.H, Pop1.H, Pop2.H"
  public static unsafe Vector<ushort> TransposeEven(Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svtrn1[_u32](svuint32_t op1, svuint32_t op2) : "TRN1 Zresult.S, Zop1.S, Zop2.S"
    /// svbool_t svtrn1_b32(svbool_t op1, svbool_t op2) : "TRN1 Presult.S, Pop1.S, Pop2.S"
  public static unsafe Vector<uint> TransposeEven(Vector<uint> left, Vector<uint> right);

    /// svuint64_t svtrn1[_u64](svuint64_t op1, svuint64_t op2) : "TRN1 Zresult.D, Zop1.D, Zop2.D"
    /// svbool_t svtrn1_b64(svbool_t op1, svbool_t op2) : "TRN1 Presult.D, Pop1.D, Pop2.D"
  public static unsafe Vector<ulong> TransposeEven(Vector<ulong> left, Vector<ulong> right);


    /// TransposeOdd : Interleave odd elements from two inputs

    /// svfloat32_t svtrn2[_f32](svfloat32_t op1, svfloat32_t op2) : "TRN2 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<float> TransposeOdd(Vector<float> left, Vector<float> right);

    /// svfloat64_t svtrn2[_f64](svfloat64_t op1, svfloat64_t op2) : "TRN2 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<double> TransposeOdd(Vector<double> left, Vector<double> right);

    /// svint8_t svtrn2[_s8](svint8_t op1, svint8_t op2) : "TRN2 Zresult.B, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> TransposeOdd(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svtrn2[_s16](svint16_t op1, svint16_t op2) : "TRN2 Zresult.H, Zop1.H, Zop2.H"
  public static unsafe Vector<short> TransposeOdd(Vector<short> left, Vector<short> right);

    /// svint32_t svtrn2[_s32](svint32_t op1, svint32_t op2) : "TRN2 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<int> TransposeOdd(Vector<int> left, Vector<int> right);

    /// svint64_t svtrn2[_s64](svint64_t op1, svint64_t op2) : "TRN2 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<long> TransposeOdd(Vector<long> left, Vector<long> right);

    /// svuint8_t svtrn2[_u8](svuint8_t op1, svuint8_t op2) : "TRN2 Zresult.B, Zop1.B, Zop2.B"
    /// svbool_t svtrn2_b8(svbool_t op1, svbool_t op2) : "TRN2 Presult.B, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> TransposeOdd(Vector<byte> left, Vector<byte> right);

    /// svuint16_t svtrn2[_u16](svuint16_t op1, svuint16_t op2) : "TRN2 Zresult.H, Zop1.H, Zop2.H"
    /// svbool_t svtrn2_b16(svbool_t op1, svbool_t op2) : "TRN2 Presult.H, Pop1.H, Pop2.H"
  public static unsafe Vector<ushort> TransposeOdd(Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svtrn2[_u32](svuint32_t op1, svuint32_t op2) : "TRN2 Zresult.S, Zop1.S, Zop2.S"
    /// svbool_t svtrn2_b32(svbool_t op1, svbool_t op2) : "TRN2 Presult.S, Pop1.S, Pop2.S"
  public static unsafe Vector<uint> TransposeOdd(Vector<uint> left, Vector<uint> right);

    /// svuint64_t svtrn2[_u64](svuint64_t op1, svuint64_t op2) : "TRN2 Zresult.D, Zop1.D, Zop2.D"
    /// svbool_t svtrn2_b64(svbool_t op1, svbool_t op2) : "TRN2 Presult.D, Pop1.D, Pop2.D"
  public static unsafe Vector<ulong> TransposeOdd(Vector<ulong> left, Vector<ulong> right);


    /// UnzipEven : Concatenate even elements from two inputs

    /// svfloat32_t svuzp1[_f32](svfloat32_t op1, svfloat32_t op2) : "UZP1 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<float> UnzipEven(Vector<float> left, Vector<float> right);

    /// svfloat64_t svuzp1[_f64](svfloat64_t op1, svfloat64_t op2) : "UZP1 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<double> UnzipEven(Vector<double> left, Vector<double> right);

    /// svint8_t svuzp1[_s8](svint8_t op1, svint8_t op2) : "UZP1 Zresult.B, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> UnzipEven(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svuzp1[_s16](svint16_t op1, svint16_t op2) : "UZP1 Zresult.H, Zop1.H, Zop2.H"
  public static unsafe Vector<short> UnzipEven(Vector<short> left, Vector<short> right);

    /// svint32_t svuzp1[_s32](svint32_t op1, svint32_t op2) : "UZP1 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<int> UnzipEven(Vector<int> left, Vector<int> right);

    /// svint64_t svuzp1[_s64](svint64_t op1, svint64_t op2) : "UZP1 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<long> UnzipEven(Vector<long> left, Vector<long> right);

    /// svuint8_t svuzp1[_u8](svuint8_t op1, svuint8_t op2) : "UZP1 Zresult.B, Zop1.B, Zop2.B"
    /// svbool_t svuzp1_b8(svbool_t op1, svbool_t op2) : "UZP1 Presult.B, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> UnzipEven(Vector<byte> left, Vector<byte> right);

    /// svuint16_t svuzp1[_u16](svuint16_t op1, svuint16_t op2) : "UZP1 Zresult.H, Zop1.H, Zop2.H"
    /// svbool_t svuzp1_b16(svbool_t op1, svbool_t op2) : "UZP1 Presult.H, Pop1.H, Pop2.H"
  public static unsafe Vector<ushort> UnzipEven(Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svuzp1[_u32](svuint32_t op1, svuint32_t op2) : "UZP1 Zresult.S, Zop1.S, Zop2.S"
    /// svbool_t svuzp1_b32(svbool_t op1, svbool_t op2) : "UZP1 Presult.S, Pop1.S, Pop2.S"
  public static unsafe Vector<uint> UnzipEven(Vector<uint> left, Vector<uint> right);

    /// svuint64_t svuzp1[_u64](svuint64_t op1, svuint64_t op2) : "UZP1 Zresult.D, Zop1.D, Zop2.D"
    /// svbool_t svuzp1_b64(svbool_t op1, svbool_t op2) : "UZP1 Presult.D, Pop1.D, Pop2.D"
  public static unsafe Vector<ulong> UnzipEven(Vector<ulong> left, Vector<ulong> right);


    /// UnzipOdd : Concatenate odd elements from two inputs

    /// svfloat32_t svuzp2[_f32](svfloat32_t op1, svfloat32_t op2) : "UZP2 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<float> UnzipOdd(Vector<float> left, Vector<float> right);

    /// svfloat64_t svuzp2[_f64](svfloat64_t op1, svfloat64_t op2) : "UZP2 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<double> UnzipOdd(Vector<double> left, Vector<double> right);

    /// svint8_t svuzp2[_s8](svint8_t op1, svint8_t op2) : "UZP2 Zresult.B, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> UnzipOdd(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svuzp2[_s16](svint16_t op1, svint16_t op2) : "UZP2 Zresult.H, Zop1.H, Zop2.H"
  public static unsafe Vector<short> UnzipOdd(Vector<short> left, Vector<short> right);

    /// svint32_t svuzp2[_s32](svint32_t op1, svint32_t op2) : "UZP2 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<int> UnzipOdd(Vector<int> left, Vector<int> right);

    /// svint64_t svuzp2[_s64](svint64_t op1, svint64_t op2) : "UZP2 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<long> UnzipOdd(Vector<long> left, Vector<long> right);

    /// svuint8_t svuzp2[_u8](svuint8_t op1, svuint8_t op2) : "UZP2 Zresult.B, Zop1.B, Zop2.B"
    /// svbool_t svuzp2_b8(svbool_t op1, svbool_t op2) : "UZP2 Presult.B, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> UnzipOdd(Vector<byte> left, Vector<byte> right);

    /// svuint16_t svuzp2[_u16](svuint16_t op1, svuint16_t op2) : "UZP2 Zresult.H, Zop1.H, Zop2.H"
    /// svbool_t svuzp2_b16(svbool_t op1, svbool_t op2) : "UZP2 Presult.H, Pop1.H, Pop2.H"
  public static unsafe Vector<ushort> UnzipOdd(Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svuzp2[_u32](svuint32_t op1, svuint32_t op2) : "UZP2 Zresult.S, Zop1.S, Zop2.S"
    /// svbool_t svuzp2_b32(svbool_t op1, svbool_t op2) : "UZP2 Presult.S, Pop1.S, Pop2.S"
  public static unsafe Vector<uint> UnzipOdd(Vector<uint> left, Vector<uint> right);

    /// svuint64_t svuzp2[_u64](svuint64_t op1, svuint64_t op2) : "UZP2 Zresult.D, Zop1.D, Zop2.D"
    /// svbool_t svuzp2_b64(svbool_t op1, svbool_t op2) : "UZP2 Presult.D, Pop1.D, Pop2.D"
  public static unsafe Vector<ulong> UnzipOdd(Vector<ulong> left, Vector<ulong> right);


    /// VectorTableLookup : Table lookup in single-vector table

    /// svfloat32_t svtbl[_f32](svfloat32_t data, svuint32_t indices) : "TBL Zresult.S, Zdata.S, Zindices.S"
  public static unsafe Vector<float> VectorTableLookup(Vector<float> data, Vector<uint> indices);

    /// svfloat64_t svtbl[_f64](svfloat64_t data, svuint64_t indices) : "TBL Zresult.D, Zdata.D, Zindices.D"
  public static unsafe Vector<double> VectorTableLookup(Vector<double> data, Vector<ulong> indices);

    /// svint8_t svtbl[_s8](svint8_t data, svuint8_t indices) : "TBL Zresult.B, Zdata.B, Zindices.B"
  public static unsafe Vector<sbyte> VectorTableLookup(Vector<sbyte> data, Vector<byte> indices);

    /// svint16_t svtbl[_s16](svint16_t data, svuint16_t indices) : "TBL Zresult.H, Zdata.H, Zindices.H"
  public static unsafe Vector<short> VectorTableLookup(Vector<short> data, Vector<ushort> indices);

    /// svint32_t svtbl[_s32](svint32_t data, svuint32_t indices) : "TBL Zresult.S, Zdata.S, Zindices.S"
  public static unsafe Vector<int> VectorTableLookup(Vector<int> data, Vector<uint> indices);

    /// svint64_t svtbl[_s64](svint64_t data, svuint64_t indices) : "TBL Zresult.D, Zdata.D, Zindices.D"
  public static unsafe Vector<long> VectorTableLookup(Vector<long> data, Vector<ulong> indices);

    /// svuint8_t svtbl[_u8](svuint8_t data, svuint8_t indices) : "TBL Zresult.B, Zdata.B, Zindices.B"
  public static unsafe Vector<byte> VectorTableLookup(Vector<byte> data, Vector<byte> indices);

    /// svuint16_t svtbl[_u16](svuint16_t data, svuint16_t indices) : "TBL Zresult.H, Zdata.H, Zindices.H"
  public static unsafe Vector<ushort> VectorTableLookup(Vector<ushort> data, Vector<ushort> indices);

    /// svuint32_t svtbl[_u32](svuint32_t data, svuint32_t indices) : "TBL Zresult.S, Zdata.S, Zindices.S"
  public static unsafe Vector<uint> VectorTableLookup(Vector<uint> data, Vector<uint> indices);

    /// svuint64_t svtbl[_u64](svuint64_t data, svuint64_t indices) : "TBL Zresult.D, Zdata.D, Zindices.D"
  public static unsafe Vector<ulong> VectorTableLookup(Vector<ulong> data, Vector<ulong> indices);


    /// ZipHigh : Interleave elements from high halves of two inputs

    /// svfloat32_t svzip2[_f32](svfloat32_t op1, svfloat32_t op2) : "ZIP2 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<float> ZipHigh(Vector<float> left, Vector<float> right);

    /// svfloat64_t svzip2[_f64](svfloat64_t op1, svfloat64_t op2) : "ZIP2 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<double> ZipHigh(Vector<double> left, Vector<double> right);

    /// svint8_t svzip2[_s8](svint8_t op1, svint8_t op2) : "ZIP2 Zresult.B, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> ZipHigh(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svzip2[_s16](svint16_t op1, svint16_t op2) : "ZIP2 Zresult.H, Zop1.H, Zop2.H"
  public static unsafe Vector<short> ZipHigh(Vector<short> left, Vector<short> right);

    /// svint32_t svzip2[_s32](svint32_t op1, svint32_t op2) : "ZIP2 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<int> ZipHigh(Vector<int> left, Vector<int> right);

    /// svint64_t svzip2[_s64](svint64_t op1, svint64_t op2) : "ZIP2 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<long> ZipHigh(Vector<long> left, Vector<long> right);

    /// svuint8_t svzip2[_u8](svuint8_t op1, svuint8_t op2) : "ZIP2 Zresult.B, Zop1.B, Zop2.B"
    /// svbool_t svzip2_b8(svbool_t op1, svbool_t op2) : "ZIP2 Presult.B, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> ZipHigh(Vector<byte> left, Vector<byte> right);

    /// svuint16_t svzip2[_u16](svuint16_t op1, svuint16_t op2) : "ZIP2 Zresult.H, Zop1.H, Zop2.H"
    /// svbool_t svzip2_b16(svbool_t op1, svbool_t op2) : "ZIP2 Presult.H, Pop1.H, Pop2.H"
  public static unsafe Vector<ushort> ZipHigh(Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svzip2[_u32](svuint32_t op1, svuint32_t op2) : "ZIP2 Zresult.S, Zop1.S, Zop2.S"
    /// svbool_t svzip2_b32(svbool_t op1, svbool_t op2) : "ZIP2 Presult.S, Pop1.S, Pop2.S"
  public static unsafe Vector<uint> ZipHigh(Vector<uint> left, Vector<uint> right);

    /// svuint64_t svzip2[_u64](svuint64_t op1, svuint64_t op2) : "ZIP2 Zresult.D, Zop1.D, Zop2.D"
    /// svbool_t svzip2_b64(svbool_t op1, svbool_t op2) : "ZIP2 Presult.D, Pop1.D, Pop2.D"
  public static unsafe Vector<ulong> ZipHigh(Vector<ulong> left, Vector<ulong> right);


    /// ZipLow : Interleave elements from low halves of two inputs

    /// svfloat32_t svzip1[_f32](svfloat32_t op1, svfloat32_t op2) : "ZIP1 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<float> ZipLow(Vector<float> left, Vector<float> right);

    /// svfloat64_t svzip1[_f64](svfloat64_t op1, svfloat64_t op2) : "ZIP1 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<double> ZipLow(Vector<double> left, Vector<double> right);

    /// svint8_t svzip1[_s8](svint8_t op1, svint8_t op2) : "ZIP1 Zresult.B, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> ZipLow(Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svzip1[_s16](svint16_t op1, svint16_t op2) : "ZIP1 Zresult.H, Zop1.H, Zop2.H"
  public static unsafe Vector<short> ZipLow(Vector<short> left, Vector<short> right);

    /// svint32_t svzip1[_s32](svint32_t op1, svint32_t op2) : "ZIP1 Zresult.S, Zop1.S, Zop2.S"
  public static unsafe Vector<int> ZipLow(Vector<int> left, Vector<int> right);

    /// svint64_t svzip1[_s64](svint64_t op1, svint64_t op2) : "ZIP1 Zresult.D, Zop1.D, Zop2.D"
  public static unsafe Vector<long> ZipLow(Vector<long> left, Vector<long> right);

    /// svuint8_t svzip1[_u8](svuint8_t op1, svuint8_t op2) : "ZIP1 Zresult.B, Zop1.B, Zop2.B"
    /// svbool_t svzip1_b8(svbool_t op1, svbool_t op2) : "ZIP1 Presult.B, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> ZipLow(Vector<byte> left, Vector<byte> right);

    /// svuint16_t svzip1[_u16](svuint16_t op1, svuint16_t op2) : "ZIP1 Zresult.H, Zop1.H, Zop2.H"
    /// svbool_t svzip1_b16(svbool_t op1, svbool_t op2) : "ZIP1 Presult.H, Pop1.H, Pop2.H"
  public static unsafe Vector<ushort> ZipLow(Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svzip1[_u32](svuint32_t op1, svuint32_t op2) : "ZIP1 Zresult.S, Zop1.S, Zop2.S"
    /// svbool_t svzip1_b32(svbool_t op1, svbool_t op2) : "ZIP1 Presult.S, Pop1.S, Pop2.S"
  public static unsafe Vector<uint> ZipLow(Vector<uint> left, Vector<uint> right);

    /// svuint64_t svzip1[_u64](svuint64_t op1, svuint64_t op2) : "ZIP1 Zresult.D, Zop1.D, Zop2.D"
    /// svbool_t svzip1_b64(svbool_t op1, svbool_t op2) : "ZIP1 Presult.D, Pop1.D, Pop2.D"
  public static unsafe Vector<ulong> ZipLow(Vector<ulong> left, Vector<ulong> right);


  /// total method signatures: 145
  /// total method names:      16
}

[a74nh]

  /// Rejected:
  ///   public static unsafe Vector<sbyte> Move(Vector<sbyte> value); // svmov[_b]_z
  ///   public static unsafe Vector<short> Move(Vector<short> value); // svmov[_b]_z
  ///   public static unsafe Vector<int> Move(Vector<int> value); // svmov[_b]_z
  ///   public static unsafe Vector<long> Move(Vector<long> value); // svmov[_b]_z
  ///   public static unsafe Vector<byte> Move(Vector<byte> value); // svmov[_b]_z
  ///   public static unsafe Vector<ushort> Move(Vector<ushort> value); // svmov[_b]_z
  ///   public static unsafe Vector<uint> Move(Vector<uint> value); // svmov[_b]_z
  ///   public static unsafe Vector<ulong> Move(Vector<ulong> value); // svmov[_b]_z
  ///   Total Rejected: 8

  /// Total ACLE covered across API:      254

[a74nh]

This contributes to #93095

It covers instructions in FEAT_SVE, containing methods related to moving around bits, moving vectors and zipping.

This list was auto generated from the C ACLE for SVE, and is in three parts:

The methods list reduced down to Vector versions. All possible varaints of T are given above the method.
The complete list of all methods. The corresponding ACLE methods and SVE instructions are given above the method.
All rejected ACLE methods. These are methods we have agreed that do not need including in C#.
Where possible, existing C# naming conventions have been matched.

Many of the C functions include predicate argument(s), of type svbool_t as the first argument. These are missing from the C# method. It is expected that the Jit will create predicates where required, or combine with uses of conditionalSelect(). For more discussion see #88140 comment.

[tannergooding]

For DuplicateToVector(Vector<T> data, ushort index), the AdvSimd equivalent calls it DuplicateSelectedScalarToVector

Index probably needs a different name that clarifies what it's doing (creating a vector that starts that base and where each subsequent element is +step higher than the previous). It's potentially a case where a cross platform API directly on Vector would also be desirable, particularly given this is also a common need for vector code in general. Something like Vector<T> CreateIndex(T base, T step), or maybe a name like CreateSequence, exposed on Vector would work. I don't have a preference on whether Sve exposes the same API or not.

Is Move just a nop? Is it actually needed?

Splice is a new term, we probably want to give an example of what it does.

This issue has been marked needs-author-action and may be missing some important information.

[a74nh]

For DuplicateToVector(Vector<T> data, ushort index), the AdvSimd equivalent calls it DuplicateSelectedScalarToVector

Done.

Index probably needs a different name that clarifies what it's doing (creating a vector that starts that base and where each subsequent element is +step higher than the previous). It's potentially a case where a cross platform API directly on Vector would also be desirable, particularly given this is also a common need for vector code in general. Something like Vector<T> CreateIndex(T base, T step), or maybe a name like CreateSequence, exposed on Vector would work. I don't have a preference on whether Sve exposes the same API or not.

I've used CreateSeries() because that matches the description better.

Is Move just a nop? Is it actually needed?

Agreed. Removed.

Splice is a new term, we probably want to give an example of what it does.

Added a description. Also, this doesn't make sense without a mask, so I've added that back in.