Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[API Proposal]: Arm64: FEAT_SVE: mask #93964

Open
a74nh opened this issue Oct 25, 2023 · 15 comments
Open

[API Proposal]: Arm64: FEAT_SVE: mask #93964

a74nh opened this issue Oct 25, 2023 · 15 comments
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics arm-sve Work related to arm64 SVE/SVE2 support
Milestone
10.0.0

Comments

@a74nh
Copy link
Contributor

a74nh commented Oct 25, 2023 •
edited
Loading 

namespace System.Runtime.Intrinsics.Arm;

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

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double, int, long, uint, ulong
  public static unsafe Vector<T> Compact(Vector<T> mask, Vector<T> value); // COMPACT

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T> right); // FCMEQ or CMPEQ // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T2> right); // CMPEQ // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T2> right); // CMPGT or CMPHI // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T2> right); // CMPGE or CMPHS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T2> right); // CMPLT or CMPLO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T2> right); // CMPLE or CMPLS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T> right); // FCMNE or CMPNE // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T2> right); // CMPNE // predicated

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, Vector<T> right); // FCMUO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractAfterLastActiveElement(Vector<T> mask, Vector<T> fallback, Vector<T> data); // CLASTA // MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractLastActiveElement(Vector<T> mask, Vector<T> fallback, Vector<T> data); // CLASTB // MOVPRFX

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

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakAfterMask(Vector<T> mask, Vector<T> from); // BRKA // predicated

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakAfterPropagateMask(Vector<T> mask, Vector<T> left, Vector<T> right); // BRKPA

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakBeforeMask(Vector<T> mask, Vector<T> from); // BRKB // predicated

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateBreakBeforePropagateMask(Vector<T> mask, Vector<T> left, Vector<T> right); // BRKPB

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(int left, int right); // WHILELT

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(long left, long right); // WHILELT

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(uint left, uint right); // WHILELO

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanMask(ulong left, ulong right); // WHILELO

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(int left, int right); // WHILELE

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(long left, long right); // WHILELE

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(uint left, uint right); // WHILELS

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> CreateWhileLessThanOrEqualMask(ulong left, ulong right); // WHILELS

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

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

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ExtractVector(Vector<T> upper, Vector<T> lower, ulong index); // EXT // MOVPRFX

  public static unsafe Vector<byte> FalseMask(); // PFALSE

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskGetFirstSet(Vector<T> mask, Vector<T> from); // PNEXT

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskSetFirst(Vector<T> mask, Vector<T> from); // PFIRST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe bool MaskTestAnyTrue(Vector<T> mask, Vector<T> from); // PTEST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe bool MaskTestFirstTrue(Vector<T> mask, Vector<T> from); // PTEST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe bool MaskTestLastTrue(Vector<T> mask, Vector<T> from); // PTEST

  /// T: sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> PropagateBreak(Vector<T> left, Vector<T> right); // BRKN // predicated

  public static unsafe Vector<byte> TrueMask(); // PTRUE

  public static unsafe Vector<byte> TrueMask([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All); // PTRUE


  // All patterns used by PTRUE.
  public enum SveMaskPattern : byte
  {
    LargestPowerOf2 = 0,   // The largest power of 2.
    VectorCount1 = 1,    // 1 element.
    VectorCount2 = 2,    // 2 elements.
    VectorCount3 = 3,    // 3 elements.
    VectorCount4 = 4,    // 4 elements.
    VectorCount5 = 5,    // 5 elements.
    VectorCount6 = 6,    // 6 elements.
    VectorCount7 = 7,    // 7 elements.
    VectorCount8 = 8,    // 8 elements.
    VectorCount16 = 9,   // 16 elements.
    VectorCount32 = 10,  // 32 elements.
    VectorCount64 = 11,  // 64 elements.
    VectorCount128 = 12, // 128 elements.
    VectorCount256 = 13, // 256 elements.
    LargestMultipleOf4 = 29,  // The largest multiple of 4.
    LargestMultipleOf3 = 30,  // The largest multiple of 3.
    All  = 31    // All available (implicitly a multiple of two).
  };

  /// total method signatures: 45


  /// Optional Entries:

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, T right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, T right); // FACGE // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, T right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, T right); // FACGE // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareEqual(Vector<T> left, T right); // FCMEQ or CMPEQ // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareEqual(Vector<T> left, long right); // CMPEQ // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, T right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, long right); // CMPGT // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, ulong right); // CMPHI // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, T right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, long right); // CMPGE // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, ulong right); // CMPHS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, T right); // FCMLT or FCMGT or CMPLT or CMPGT or CMPLO or CMPHI // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, long right); // CMPLT // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, ulong right); // CMPLO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, T right); // FCMLE or FCMGE or CMPLE or CMPGE or CMPLS or CMPHS // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, long right); // CMPLE // predicated

  /// T: byte, ushort, uint
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, ulong right); // CMPLS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, T right); // FCMNE or CMPNE // predicated

  /// T: sbyte, short, int
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, long right); // CMPNE // predicated

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, T right); // FCMUO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe T ConditionalExtractAfterLastActiveElement(Vector<T> mask, T fallback, Vector<T> data); // CLASTA

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe T ConditionalExtractLastActiveElement(Vector<T> mask, T fallback, Vector<T> data); // CLASTB

  /// total optional method signatures: 23

}

For all methods where the first argument is a vector mask, this is used used to determine the active elements in the input.

TrueMask

Set elements of the destination predicate to true if the element number satisfies the constraint pattern, or to false otherwise. If the constraint specifies more elements than are available at the current vector length then all elements of the destination predicate are set to false.

Returns a byte mask. This can safely be cast to a mask of any Vector type.

Compact

Shuffle active elements of vector to the right and fill with zero
Read the active elements from the source vector and pack them into the lowest-numbered elements of the destination vector. Then set any remaining elements of the destination vector to zero.

CreateWhileLessThanMask

While incrementing signed scalar less than scalar

Generate a mask that starting from the lowest numbered element is true while the incrementing value of the scalar operand left is less than the scalar right operand and false thereafter up to the highest numbered element.

This is used to create a mask for the current iteration of a loop, where the final iteration may not fill a full vector width. For example:

// Add all values in an array
for (i=0; i<size; i++)
{
  vector<int> mask = Sve.CreateWhileLessThanMask(i, size);
  vector<int> values = Sve.LoadVectorInt32(mask, base);
  total = Sve.ConditionalSelect(mask, total + values, total);
  base += Sve.GetActiveElementCount(mask);
}
return Sve.AddReduce(total);

CreateWhileLessThanOrEqualMask

While incrementing signed scalar less than scalar. Similar to CreateWhileLessThanMask.

MaskSetFirst

Set the first active mask element to true

Returns a copy of the mask from, with the first active element set to true.

MaskGetFirstSet

Find next active predicate

Used to construct a loop which iterates over all true elements in mask.

If all elements in the mask from are false it finds the first true element in mask. Otherwise it finds the next true element in mask that follows the last true element in from. Returns a mask with the found element true and all other elements false.

TODO: add example.

CreateBreakAfterMask

Break after first true condition

Returns a mask containing true up to and including the first active element in from that is also true. All subsequent elements are set to false. Inactive elements in the destination predicate register remain unmodified or are set to zero, depending on whether merging or zeroing predication is selected

//  for (int i = 0; i < n; i++)
//  {
//    res += a[i] * b[i];
//    if (a[i] == 512) { break; }
//  }
for (int i = 0;
       Sve.TestFirstTrue(Sve.TrueMask(), p0 = Sve.CreateWhileLessThanMask(i, n)); 
       i += Count32BitElements())
  {
    vector<unit> a_vec = Sve.LoadVector(p0, a);
    vector<unit> b_vec = Sve.LoadVector(p0, b);
    vector<unit> p1 = Sve.CompareEqual(p0, a_vec, 512);
    if (Sve.TestAnyTrue(p0, p1))
    {  
      // One of the entries is 512. Get a mask that is true to the first match.
      // Do the final entries with the mask.
      p1 = Sve.CreateBreakAfterMask(p0, p1);
      res_vec = Sve.ConditionalSelect(p1, Sve.MultiplyAdd(, res_vec, a_vec, b_vec), res_vec);
      break;
    }
    else
    {
      // Use the loop mask p0. For the final iteration this may be a parital vector.
      res_vec = Sve.ConditionalSelect(p0, Sve.MultiplyAdd(, res_vec, a_vec, b_vec), res_vec);
      a += Sve.Count32BitElements();
      b += Sve.Count32BitElements();
    }
  }
  return Sve.AddAcross(res_vec);

CreateBreakAfterPropagateMask, CreateBreakBeforePropagateMask

ExtractAfterLast, ConditionalExtractAfterLastActiveElement
@ghost ghost added the untriaged New issue has not been triaged by the area owner label Oct 25, 2023
@ghost
Copy link

ghost commented Oct 25, 2023

Tagging subscribers to this area: @dotnet/area-system-runtime-intrinsics
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: mask
{
  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, Vector<T> right);

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, Vector<T> right);

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, Vector<T> right);

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, Vector<T> right);

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

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

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

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

  /// T: float, double, int, long, uint, ulong
  public static unsafe Vector<T> Compact(Vector<T> mask, Vector<T> op);

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

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareEqualTo(Vector<T> left, Vector<T2> right);

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

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T2> right);

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

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T2> right);

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

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T2> right);

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

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T2> right);

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

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T2> right);

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, Vector<T> right);

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractAfterLast(Vector<T> mask, Vector<T> fallback, Vector<T> data);

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractLast(Vector<T> mask, Vector<T> fallback, Vector<T> data);

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalSelect(Vector<T> mask, Vector<T> op1, Vector<T> op2);

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

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

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint
  public static unsafe Vector<T> ExtractVector(Vector<T> upper, Vector<T> lower, ulong index);

  public static unsafe Vector<ulong> ExtractVector(Vector<ulong> upper, Vector<ulong> lower, ulong index);

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

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskGetFirstSet(Vector<T> value);

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskSetAll();

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> MaskSetAll(enum svpattern pattern);

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

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

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> WhileLessThan(int left, int right);

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> WhileLessThan(long left, long right);

  /// T: byte, ushort, ulong
  public static unsafe Vector<T> WhileLessThan(uint left, uint right);

  /// T: byte, ushort, uint
  public static unsafe Vector<T> WhileLessThan(ulong left, ulong right);

  /// T: uint, ulong
  public static unsafe Vector<T> WhileLessThan(T left, T right);

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> WhileLessThanOrEqual(int left, int right);

  /// T: byte, ushort, uint, ulong
  public static unsafe Vector<T> WhileLessThanOrEqual(long left, long right);

  /// T: byte, ushort, ulong
  public static unsafe Vector<T> WhileLessThanOrEqual(uint left, uint right);

  /// T: byte, ushort, uint
  public static unsafe Vector<T> WhileLessThanOrEqual(ulong left, ulong right);

  /// T: uint, ulong
  public static unsafe Vector<T> WhileLessThanOrEqual(T left, T right);

  /// total method signatures: 45
}


/// Full API
public abstract class Sve : AdvSimd /// Feature: FEAT_SVE  Category: mask
{
    /// AbsoluteCompareGreaterThan : Absolute compare greater than

    /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> AbsoluteCompareGreaterThan(Vector<float> left, Vector<float> right);

    /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> AbsoluteCompareGreaterThan(Vector<double> left, Vector<double> right);


    /// AbsoluteCompareGreaterThanOrEqual : Absolute compare greater than or equal to

    /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> AbsoluteCompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> AbsoluteCompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);


    /// AbsoluteCompareLessThan : Absolute compare less than

    /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> AbsoluteCompareLessThan(Vector<float> left, Vector<float> right);

    /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> AbsoluteCompareLessThan(Vector<double> left, Vector<double> right);


    /// AbsoluteCompareLessThanOrEqual : Absolute compare less than or equal to

    /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> AbsoluteCompareLessThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> AbsoluteCompareLessThanOrEqual(Vector<double> left, Vector<double> right);


    /// BreakAfter : Break after first true condition

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<sbyte> BreakAfter(Vector<sbyte> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<short> BreakAfter(Vector<short> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<int> BreakAfter(Vector<int> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<long> BreakAfter(Vector<long> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<byte> BreakAfter(Vector<byte> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ushort> BreakAfter(Vector<ushort> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<uint> BreakAfter(Vector<uint> value);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ulong> BreakAfter(Vector<ulong> value);


    /// BreakAfterPropagate : Break after first true condition, propagating from previous partition

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> BreakAfterPropagate(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<short> BreakAfterPropagate(Vector<short> left, Vector<short> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<int> BreakAfterPropagate(Vector<int> left, Vector<int> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<long> BreakAfterPropagate(Vector<long> left, Vector<long> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> BreakAfterPropagate(Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> BreakAfterPropagate(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> BreakAfterPropagate(Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> BreakAfterPropagate(Vector<ulong> left, Vector<ulong> right);


    /// BreakBefore : Break before first true condition

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<sbyte> BreakBefore(Vector<sbyte> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<short> BreakBefore(Vector<short> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<int> BreakBefore(Vector<int> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<long> BreakBefore(Vector<long> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<byte> BreakBefore(Vector<byte> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ushort> BreakBefore(Vector<ushort> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<uint> BreakBefore(Vector<uint> value);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ulong> BreakBefore(Vector<ulong> value);


    /// BreakBeforePropagate : Break before first true condition, propagating from previous partition

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> BreakBeforePropagate(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<short> BreakBeforePropagate(Vector<short> left, Vector<short> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<int> BreakBeforePropagate(Vector<int> left, Vector<int> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<long> BreakBeforePropagate(Vector<long> left, Vector<long> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> BreakBeforePropagate(Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> BreakBeforePropagate(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> BreakBeforePropagate(Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> BreakBeforePropagate(Vector<ulong> left, Vector<ulong> right);


    /// Compact : Shuffle active elements of vector to the right and fill with zero

    /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<float> Compact(Vector<float> mask, Vector<float> op);

    /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<double> Compact(Vector<double> mask, Vector<double> op);

    /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<int> Compact(Vector<int> mask, Vector<int> op);

    /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<long> Compact(Vector<long> mask, Vector<long> op);

    /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<uint> Compact(Vector<uint> mask, Vector<uint> op);

    /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<ulong> Compact(Vector<ulong> mask, Vector<ulong> op);


    /// CompareEqualTo : Compare equal to

    /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareEqualTo(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareEqualTo(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareEqualTo(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareEqualTo(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareEqualTo(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareEqualTo(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareEqualTo(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareEqualTo(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareEqualTo(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareEqualTo(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareEqualTo(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareEqualTo(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareEqualTo(Vector<int> left, Vector<long> right);


    /// CompareGreaterThan : Compare greater than

    /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareGreaterThan(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareGreaterThan(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareGreaterThan(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareGreaterThan(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<ulong> right);


    /// CompareGreaterThanOrEqual : Compare greater than or equal to

    /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareGreaterThanOrEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareGreaterThanOrEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<ulong> right);


    /// CompareLessThan : Compare less than

    /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> CompareLessThan(Vector<float> left, Vector<float> right);

    /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> CompareLessThan(Vector<double> left, Vector<double> right);

    /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<short> CompareLessThan(Vector<short> left, Vector<short> right);

    /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<int> CompareLessThan(Vector<int> left, Vector<int> right);

    /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<long> CompareLessThan(Vector<long> left, Vector<long> right);

    /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<ulong> CompareLessThan(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareLessThan(Vector<short> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareLessThan(Vector<int> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, Vector<ulong> right);


    /// CompareLessThanOrEqual : Compare less than or equal to

    /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> CompareLessThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> CompareLessThanOrEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<long> CompareLessThanOrEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<ulong> CompareLessThanOrEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<long> right);

    /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<ulong> right);


    /// CompareNotEqualTo : Compare not equal to

    /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareNotEqualTo(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareNotEqualTo(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareNotEqualTo(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareNotEqualTo(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareNotEqualTo(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareNotEqualTo(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareNotEqualTo(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, Vector<long> right);


    /// CompareUnordered : Compare unordered with

    /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareUnordered(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareUnordered(Vector<double> left, Vector<double> right);


    /// ConditionalExtractAfterLast : Conditionally extract element after last

    /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<float> ConditionalExtractAfterLast(Vector<float> mask, Vector<float> fallback, Vector<float> data);

    /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<double> ConditionalExtractAfterLast(Vector<double> mask, Vector<double> fallback, Vector<double> data);

    /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<sbyte> ConditionalExtractAfterLast(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);

    /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<short> ConditionalExtractAfterLast(Vector<short> mask, Vector<short> fallback, Vector<short> data);

    /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<int> ConditionalExtractAfterLast(Vector<int> mask, Vector<int> fallback, Vector<int> data);

    /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<long> ConditionalExtractAfterLast(Vector<long> mask, Vector<long> fallback, Vector<long> data);

    /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<byte> ConditionalExtractAfterLast(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);

    /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<ushort> ConditionalExtractAfterLast(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);

    /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<uint> ConditionalExtractAfterLast(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);

    /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<ulong> ConditionalExtractAfterLast(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);


    /// ConditionalExtractLast : Conditionally extract last element

    /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<float> ConditionalExtractLast(Vector<float> mask, Vector<float> fallback, Vector<float> data);

    /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<double> ConditionalExtractLast(Vector<double> mask, Vector<double> fallback, Vector<double> data);

    /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<sbyte> ConditionalExtractLast(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);

    /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<short> ConditionalExtractLast(Vector<short> mask, Vector<short> fallback, Vector<short> data);

    /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<int> ConditionalExtractLast(Vector<int> mask, Vector<int> fallback, Vector<int> data);

    /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<long> ConditionalExtractLast(Vector<long> mask, Vector<long> fallback, Vector<long> data);

    /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<byte> ConditionalExtractLast(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);

    /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<ushort> ConditionalExtractLast(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);

    /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<uint> ConditionalExtractLast(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);

    /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<ulong> ConditionalExtractLast(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);


    /// ConditionalSelect : Conditionally select elements

    /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
  public static unsafe Vector<float> ConditionalSelect(Vector<float> mask, Vector<float> op1, Vector<float> op2);

    /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
  public static unsafe Vector<double> ConditionalSelect(Vector<double> mask, Vector<double> op1, Vector<double> op2);

    /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> ConditionalSelect(Vector<sbyte> mask, Vector<sbyte> op1, Vector<sbyte> op2);

    /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<short> ConditionalSelect(Vector<short> mask, Vector<short> op1, Vector<short> op2);

    /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<int> ConditionalSelect(Vector<int> mask, Vector<int> op1, Vector<int> op2);

    /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<long> ConditionalSelect(Vector<long> mask, Vector<long> op1, Vector<long> op2);

    /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> ConditionalSelect(Vector<byte> mask, Vector<byte> op1, Vector<byte> op2);

    /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> ConditionalSelect(Vector<ushort> mask, Vector<ushort> op1, Vector<ushort> op2);

    /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> ConditionalSelect(Vector<uint> mask, Vector<uint> op1, Vector<uint> op2);

    /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> ConditionalSelect(Vector<ulong> mask, Vector<ulong> op1, Vector<ulong> op2);


    /// ExtractAfterLast : Extract element after last

    /// float32_t svlasta[_f32](svbool_t pg, svfloat32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe float ExtractAfterLast(Vector<float> value);

    /// float64_t svlasta[_f64](svbool_t pg, svfloat64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe double ExtractAfterLast(Vector<double> value);

    /// int8_t svlasta[_s8](svbool_t pg, svint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B"
  public static unsafe sbyte ExtractAfterLast(Vector<sbyte> value);

    /// int16_t svlasta[_s16](svbool_t pg, svint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H"
  public static unsafe short ExtractAfterLast(Vector<short> value);

    /// int32_t svlasta[_s32](svbool_t pg, svint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe int ExtractAfterLast(Vector<int> value);

    /// int64_t svlasta[_s64](svbool_t pg, svint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe long ExtractAfterLast(Vector<long> value);

    /// uint8_t svlasta[_u8](svbool_t pg, svuint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B"
  public static unsafe byte ExtractAfterLast(Vector<byte> value);

    /// uint16_t svlasta[_u16](svbool_t pg, svuint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H"
  public static unsafe ushort ExtractAfterLast(Vector<ushort> value);

    /// uint32_t svlasta[_u32](svbool_t pg, svuint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe uint ExtractAfterLast(Vector<uint> value);

    /// uint64_t svlasta[_u64](svbool_t pg, svuint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe ulong ExtractAfterLast(Vector<ulong> value);


    /// ExtractLast : Extract last element

    /// float32_t svlastb[_f32](svbool_t pg, svfloat32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe float ExtractLast(Vector<float> value);

    /// float64_t svlastb[_f64](svbool_t pg, svfloat64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe double ExtractLast(Vector<double> value);

    /// int8_t svlastb[_s8](svbool_t pg, svint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B"
  public static unsafe sbyte ExtractLast(Vector<sbyte> value);

    /// int16_t svlastb[_s16](svbool_t pg, svint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H"
  public static unsafe short ExtractLast(Vector<short> value);

    /// int32_t svlastb[_s32](svbool_t pg, svint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe int ExtractLast(Vector<int> value);

    /// int64_t svlastb[_s64](svbool_t pg, svint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe long ExtractLast(Vector<long> value);

    /// uint8_t svlastb[_u8](svbool_t pg, svuint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B"
  public static unsafe byte ExtractLast(Vector<byte> value);

    /// uint16_t svlastb[_u16](svbool_t pg, svuint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H"
  public static unsafe ushort ExtractLast(Vector<ushort> value);

    /// uint32_t svlastb[_u32](svbool_t pg, svuint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe uint ExtractLast(Vector<uint> value);

    /// uint64_t svlastb[_u64](svbool_t pg, svuint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe ulong ExtractLast(Vector<ulong> value);


    /// ExtractVector : Extract vector from pair of vectors

    /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<float> ExtractVector(Vector<float> upper, Vector<float> lower, ulong index);

    /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<double> ExtractVector(Vector<double> upper, Vector<double> lower, ulong index);

    /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> ExtractVector(Vector<sbyte> upper, Vector<sbyte> lower, ulong index);

    /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2"
  public static unsafe Vector<short> ExtractVector(Vector<short> upper, Vector<short> lower, ulong index);

    /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<int> ExtractVector(Vector<int> upper, Vector<int> lower, ulong index);

    /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<long> ExtractVector(Vector<long> upper, Vector<long> lower, ulong index);

    /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> ExtractVector(Vector<byte> upper, Vector<byte> lower, ulong index);

    /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2"
  public static unsafe Vector<ushort> ExtractVector(Vector<ushort> upper, Vector<ushort> lower, ulong index);

    /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<uint> ExtractVector(Vector<uint> upper, Vector<uint> lower, ulong index);

    /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<ulong> ExtractVector(Vector<ulong> upper, Vector<ulong> lower, ulong index);


    /// MaskClearAll : Set all predicate elements to false

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<sbyte> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<short> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<int> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<long> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<byte> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<ushort> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<uint> MaskClearAll();

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<ulong> MaskClearAll();


    /// MaskGetFirstSet : Find next active predicate

    /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) : "PNEXT Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<byte> MaskGetFirstSet(Vector<byte> value);

    /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) : "PNEXT Ptied.H, Pg, Ptied.H"
  public static unsafe Vector<ushort> MaskGetFirstSet(Vector<ushort> value);

    /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) : "PNEXT Ptied.S, Pg, Ptied.S"
  public static unsafe Vector<uint> MaskGetFirstSet(Vector<uint> value);

    /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) : "PNEXT Ptied.D, Pg, Ptied.D"
  public static unsafe Vector<ulong> MaskGetFirstSet(Vector<ulong> value);


    /// MaskSetAll : Set predicate elements to true

    /// svbool_t svptrue_b8() : "PTRUE Presult.B, ALL"
  public static unsafe Vector<byte> MaskSetAll();

    /// svbool_t svptrue_b16() : "PTRUE Presult.H, ALL"
  public static unsafe Vector<ushort> MaskSetAll();

    /// svbool_t svptrue_b32() : "PTRUE Presult.S, ALL"
  public static unsafe Vector<uint> MaskSetAll();

    /// svbool_t svptrue_b64() : "PTRUE Presult.D, ALL"
  public static unsafe Vector<ulong> MaskSetAll();

    /// svbool_t svptrue_pat_b8(enum svpattern pattern) : "PTRUE Presult.B, pattern"
  public static unsafe Vector<byte> MaskSetAll(enum svpattern pattern);

    /// svbool_t svptrue_pat_b16(enum svpattern pattern) : "PTRUE Presult.H, pattern"
  public static unsafe Vector<ushort> MaskSetAll(enum svpattern pattern);

    /// svbool_t svptrue_pat_b32(enum svpattern pattern) : "PTRUE Presult.S, pattern"
  public static unsafe Vector<uint> MaskSetAll(enum svpattern pattern);

    /// svbool_t svptrue_pat_b64(enum svpattern pattern) : "PTRUE Presult.D, pattern"
  public static unsafe Vector<ulong> MaskSetAll(enum svpattern pattern);


    /// MaskSetFirst : Set the first active predicate element to true

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<sbyte> MaskSetFirst(Vector<sbyte> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<short> MaskSetFirst(Vector<short> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<int> MaskSetFirst(Vector<int> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<long> MaskSetFirst(Vector<long> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<byte> MaskSetFirst(Vector<byte> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<ushort> MaskSetFirst(Vector<ushort> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<uint> MaskSetFirst(Vector<uint> value);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<ulong> MaskSetFirst(Vector<ulong> value);


    /// PropagateBreak : Propagate break to next partition

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<sbyte> PropagateBreak(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<short> PropagateBreak(Vector<short> left, Vector<short> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<int> PropagateBreak(Vector<int> left, Vector<int> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<long> PropagateBreak(Vector<long> left, Vector<long> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<byte> PropagateBreak(Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<ushort> PropagateBreak(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<uint> PropagateBreak(Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<ulong> PropagateBreak(Vector<ulong> left, Vector<ulong> right);


    /// WhileLessThan : While incrementing scalar is less than

    /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> WhileLessThan(int left, int right);

    /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> WhileLessThan(long left, long right);

    /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> WhileLessThan(uint left, uint right);

    /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> WhileLessThan(ulong left, ulong right);

    /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> WhileLessThan(int left, int right);

    /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> WhileLessThan(long left, long right);

    /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> WhileLessThan(uint left, uint right);

    /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> WhileLessThan(ulong left, ulong right);

    /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> WhileLessThan(int left, int right);

    /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> WhileLessThan(long left, long right);

    /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> WhileLessThan(uint left, uint right);

    /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> WhileLessThan(ulong left, ulong right);

    /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> WhileLessThan(int left, int right);

    /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> WhileLessThan(long left, long right);

    /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> WhileLessThan(uint left, uint right);

    /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> WhileLessThan(ulong left, ulong right);

///continued....
Author: a74nh
Assignees: -
Labels:

area-System.Runtime.Intrinsics, untriaged
Milestone: -

@a74nh
Copy link
Contributor Author

a74nh commented Oct 25, 2023 •
edited
Loading 

/// Full API
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: mask
{
    /// AbsoluteCompareGreaterThan : Absolute compare greater than

    /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> AbsoluteCompareGreaterThan(Vector<float> left, Vector<float> right);

    /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> AbsoluteCompareGreaterThan(Vector<double> left, Vector<double> right);


    /// AbsoluteCompareGreaterThanOrEqual : Absolute compare greater than or equal to

    /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> AbsoluteCompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> AbsoluteCompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);


    /// AbsoluteCompareLessThan : Absolute compare less than

    /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> AbsoluteCompareLessThan(Vector<float> left, Vector<float> right);

    /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> AbsoluteCompareLessThan(Vector<double> left, Vector<double> right);


    /// AbsoluteCompareLessThanOrEqual : Absolute compare less than or equal to

    /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FACGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> AbsoluteCompareLessThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FACGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> AbsoluteCompareLessThanOrEqual(Vector<double> left, Vector<double> right);


    /// Compact : Shuffle active elements of vector to the right and fill with zero

    /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<float> Compact(Vector<float> mask, Vector<float> value);

    /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<double> Compact(Vector<double> mask, Vector<double> value);

    /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<int> Compact(Vector<int> mask, Vector<int> value);

    /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<long> Compact(Vector<long> mask, Vector<long> value);

    /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) : "COMPACT Zresult.S, Pg, Zop.S"
  public static unsafe Vector<uint> Compact(Vector<uint> mask, Vector<uint> value);

    /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) : "COMPACT Zresult.D, Pg, Zop.D"
  public static unsafe Vector<ulong> Compact(Vector<ulong> mask, Vector<ulong> value);


    /// CompareEqual : Compare equal to

    /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareEqual(Vector<int> left, Vector<long> right);


    /// CompareGreaterThan : Compare greater than

    /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareGreaterThan(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareGreaterThan(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareGreaterThan(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareGreaterThan(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, Vector<long> right);

    /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<ulong> right);


    /// CompareGreaterThanOrEqual : Compare greater than or equal to

    /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareGreaterThanOrEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareGreaterThanOrEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<long> right);

    /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<ulong> right);


    /// CompareLessThan : Compare less than

    /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> CompareLessThan(Vector<float> left, Vector<float> right);

    /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> CompareLessThan(Vector<double> left, Vector<double> right);

    /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<short> CompareLessThan(Vector<short> left, Vector<short> right);

    /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<int> CompareLessThan(Vector<int> left, Vector<int> right);

    /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<long> CompareLessThan(Vector<long> left, Vector<long> right);

    /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<ulong> CompareLessThan(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareLessThan(Vector<short> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareLessThan(Vector<int> left, Vector<long> right);

    /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, Vector<ulong> right);


    /// CompareLessThanOrEqual : Compare less than or equal to

    /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<float> CompareLessThanOrEqual(Vector<float> left, Vector<float> right);

    /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<double> CompareLessThanOrEqual(Vector<double> left, Vector<double> right);

    /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<short> right);

    /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<int> right);

    /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<long> CompareLessThanOrEqual(Vector<long> left, Vector<long> right);

    /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B"
  public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H"
  public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S"
  public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D"
  public static unsafe Vector<ulong> CompareLessThanOrEqual(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<long> right);

    /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<long> right);

    /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) : "CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) : "CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ulong> right);

    /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) : "CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<ulong> right);


    /// CompareNotEqualTo : Compare not equal to

    /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareNotEqualTo(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareNotEqualTo(Vector<double> left, Vector<double> right);

    /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, Vector<short> right);

    /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, Vector<int> right);

    /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<long> CompareNotEqualTo(Vector<long> left, Vector<long> right);

    /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B"
  public static unsafe Vector<byte> CompareNotEqualTo(Vector<byte> left, Vector<byte> right);

    /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H"
  public static unsafe Vector<ushort> CompareNotEqualTo(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<uint> CompareNotEqualTo(Vector<uint> left, Vector<uint> right);

    /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<ulong> CompareNotEqualTo(Vector<ulong> left, Vector<ulong> right);

    /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) : "CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D"
  public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<long> right);

    /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) : "CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D"
  public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, Vector<long> right);

    /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) : "CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D"
  public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, Vector<long> right);


    /// CompareUnordered : Compare unordered with

    /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S"
  public static unsafe Vector<float> CompareUnordered(Vector<float> left, Vector<float> right);

    /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D"
  public static unsafe Vector<double> CompareUnordered(Vector<double> left, Vector<double> right);


    /// ConditionalExtractAfterLastActiveElement : Conditionally extract element after last

    /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<float> ConditionalExtractAfterLastActiveElement(Vector<float> mask, Vector<float> fallback, Vector<float> data);

    /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<double> ConditionalExtractAfterLastActiveElement(Vector<double> mask, Vector<double> fallback, Vector<double> data);

    /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<sbyte> ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);

    /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<short> ConditionalExtractAfterLastActiveElement(Vector<short> mask, Vector<short> fallback, Vector<short> data);

    /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<int> ConditionalExtractAfterLastActiveElement(Vector<int> mask, Vector<int> fallback, Vector<int> data);

    /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<long> ConditionalExtractAfterLastActiveElement(Vector<long> mask, Vector<long> fallback, Vector<long> data);

    /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTA Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<byte> ConditionalExtractAfterLastActiveElement(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);

    /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTA Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<ushort> ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);

    /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTA Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<uint> ConditionalExtractAfterLastActiveElement(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);

    /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTA Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTA Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<ulong> ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);


    /// ConditionalExtractLastActiveElement : Conditionally extract last element

    /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<float> ConditionalExtractLastActiveElement(Vector<float> mask, Vector<float> fallback, Vector<float> data);

    /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<double> ConditionalExtractLastActiveElement(Vector<double> mask, Vector<double> fallback, Vector<double> data);

    /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<sbyte> ConditionalExtractLastActiveElement(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);

    /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<short> ConditionalExtractLastActiveElement(Vector<short> mask, Vector<short> fallback, Vector<short> data);

    /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<int> ConditionalExtractLastActiveElement(Vector<int> mask, Vector<int> fallback, Vector<int> data);

    /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<long> ConditionalExtractLastActiveElement(Vector<long> mask, Vector<long> fallback, Vector<long> data);

    /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) : "CLASTB Ztied.B, Pg, Ztied.B, Zdata.B" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.B, Pg, Zresult.B, Zdata.B"
  public static unsafe Vector<byte> ConditionalExtractLastActiveElement(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);

    /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) : "CLASTB Ztied.H, Pg, Ztied.H, Zdata.H" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.H, Pg, Zresult.H, Zdata.H"
  public static unsafe Vector<ushort> ConditionalExtractLastActiveElement(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);

    /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) : "CLASTB Ztied.S, Pg, Ztied.S, Zdata.S" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.S, Pg, Zresult.S, Zdata.S"
  public static unsafe Vector<uint> ConditionalExtractLastActiveElement(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);

    /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) : "CLASTB Ztied.D, Pg, Ztied.D, Zdata.D" or "MOVPRFX Zresult, Zfallback; CLASTB Zresult.D, Pg, Zresult.D, Zdata.D"
  public static unsafe Vector<ulong> ConditionalExtractLastActiveElement(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);


    /// ConditionalSelect : Conditionally select elements

    /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
  public static unsafe Vector<float> ConditionalSelect(Vector<float> mask, Vector<float> left, Vector<float> right);

    /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
  public static unsafe Vector<double> ConditionalSelect(Vector<double> mask, Vector<double> left, Vector<double> right);

    /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> ConditionalSelect(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<short> ConditionalSelect(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<int> ConditionalSelect(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<long> ConditionalSelect(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) : "SEL Zresult.B, Pg, Zop1.B, Zop2.B"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> ConditionalSelect(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) : "SEL Zresult.H, Pg, Zop1.H, Zop2.H"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> ConditionalSelect(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) : "SEL Zresult.S, Pg, Zop1.S, Zop2.S"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> ConditionalSelect(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) : "SEL Zresult.D, Pg, Zop1.D, Zop2.D"
    /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) : "SEL Presult.B, Pg, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> ConditionalSelect(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);


    /// CreateBreakAfterMask : Break after first true condition

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<sbyte> CreateBreakAfterMask(Vector<sbyte> mask, Vector<sbyte> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<short> CreateBreakAfterMask(Vector<short> mask, Vector<short> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<int> CreateBreakAfterMask(Vector<int> mask, Vector<int> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<long> CreateBreakAfterMask(Vector<long> mask, Vector<long> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<byte> CreateBreakAfterMask(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ushort> CreateBreakAfterMask(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<uint> CreateBreakAfterMask(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svbrka[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKA Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) : "BRKA Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ulong> CreateBreakAfterMask(Vector<ulong> mask, Vector<ulong> from);


    /// CreateBreakAfterPropagateMask : Break after first true condition, propagating from previous partition

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> CreateBreakAfterPropagateMask(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<short> CreateBreakAfterPropagateMask(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<int> CreateBreakAfterPropagateMask(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<long> CreateBreakAfterPropagateMask(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> CreateBreakAfterPropagateMask(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> CreateBreakAfterPropagateMask(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> CreateBreakAfterPropagateMask(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> CreateBreakAfterPropagateMask(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);


    /// CreateBreakBeforeMask : Break before first true condition

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<sbyte> CreateBreakBeforeMask(Vector<sbyte> mask, Vector<sbyte> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<short> CreateBreakBeforeMask(Vector<short> mask, Vector<short> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<int> CreateBreakBeforeMask(Vector<int> mask, Vector<int> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<long> CreateBreakBeforeMask(Vector<long> mask, Vector<long> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<byte> CreateBreakBeforeMask(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ushort> CreateBreakBeforeMask(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<uint> CreateBreakBeforeMask(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svbrkb[_b]_m(svbool_t inactive, svbool_t pg, svbool_t op) : "BRKB Ptied.B, Pg/M, Pop.B"
    /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) : "BRKB Presult.B, Pg/Z, Pop.B"
  public static unsafe Vector<ulong> CreateBreakBeforeMask(Vector<ulong> mask, Vector<ulong> from);


    /// CreateBreakBeforePropagateMask : Break before first true condition, propagating from previous partition

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<sbyte> CreateBreakBeforePropagateMask(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<short> CreateBreakBeforePropagateMask(Vector<short> mask, Vector<short> left, Vector<short> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<int> CreateBreakBeforePropagateMask(Vector<int> mask, Vector<int> left, Vector<int> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<long> CreateBreakBeforePropagateMask(Vector<long> mask, Vector<long> left, Vector<long> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<byte> CreateBreakBeforePropagateMask(Vector<byte> mask, Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ushort> CreateBreakBeforePropagateMask(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<uint> CreateBreakBeforePropagateMask(Vector<uint> mask, Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B"
  public static unsafe Vector<ulong> CreateBreakBeforePropagateMask(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);


    /// CreateWhileLessThanMask : While incrementing scalar is less than

    /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanMask(ulong left, ulong right);

    /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanMask(ulong left, ulong right);

    /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanMask(ulong left, ulong right);

    /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) : "WHILELT Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(int left, int right);

    /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) : "WHILELT Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(long left, long right);

    /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) : "WHILELO Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(uint left, uint right);

    /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) : "WHILELO Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanMask(ulong left, ulong right);


    /// CreateWhileLessThanOrEqualMask : While incrementing scalar is less than or equal to

    /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.B, Wop1, Wop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.B, Xop1, Xop2"
  public static unsafe Vector<byte> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.H, Wop1, Wop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.H, Xop1, Xop2"
  public static unsafe Vector<ushort> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.S, Wop1, Wop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.S, Xop1, Xop2"
  public static unsafe Vector<uint> CreateWhileLessThanOrEqualMask(ulong left, ulong right);

    /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) : "WHILELE Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(int left, int right);

    /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) : "WHILELE Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(long left, long right);

    /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) : "WHILELS Presult.D, Wop1, Wop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(uint left, uint right);

    /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) : "WHILELS Presult.D, Xop1, Xop2"
  public static unsafe Vector<ulong> CreateWhileLessThanOrEqualMask(ulong left, ulong right);


    /// ExtractAfterLast : Extract element after last

    /// float32_t svlasta[_f32](svbool_t pg, svfloat32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe float ExtractAfterLast(Vector<float> value);

    /// float64_t svlasta[_f64](svbool_t pg, svfloat64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe double ExtractAfterLast(Vector<double> value);

    /// int8_t svlasta[_s8](svbool_t pg, svint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B"
  public static unsafe sbyte ExtractAfterLast(Vector<sbyte> value);

    /// int16_t svlasta[_s16](svbool_t pg, svint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H"
  public static unsafe short ExtractAfterLast(Vector<short> value);

    /// int32_t svlasta[_s32](svbool_t pg, svint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe int ExtractAfterLast(Vector<int> value);

    /// int64_t svlasta[_s64](svbool_t pg, svint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe long ExtractAfterLast(Vector<long> value);

    /// uint8_t svlasta[_u8](svbool_t pg, svuint8_t op) : "LASTA Wresult, Pg, Zop.B" or "LASTA Bresult, Pg, Zop.B"
  public static unsafe byte ExtractAfterLast(Vector<byte> value);

    /// uint16_t svlasta[_u16](svbool_t pg, svuint16_t op) : "LASTA Wresult, Pg, Zop.H" or "LASTA Hresult, Pg, Zop.H"
  public static unsafe ushort ExtractAfterLast(Vector<ushort> value);

    /// uint32_t svlasta[_u32](svbool_t pg, svuint32_t op) : "LASTA Wresult, Pg, Zop.S" or "LASTA Sresult, Pg, Zop.S"
  public static unsafe uint ExtractAfterLast(Vector<uint> value);

    /// uint64_t svlasta[_u64](svbool_t pg, svuint64_t op) : "LASTA Xresult, Pg, Zop.D" or "LASTA Dresult, Pg, Zop.D"
  public static unsafe ulong ExtractAfterLast(Vector<ulong> value);


    /// ExtractLast : Extract last element

    /// float32_t svlastb[_f32](svbool_t pg, svfloat32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe float ExtractLast(Vector<float> value);

    /// float64_t svlastb[_f64](svbool_t pg, svfloat64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe double ExtractLast(Vector<double> value);

    /// int8_t svlastb[_s8](svbool_t pg, svint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B"
  public static unsafe sbyte ExtractLast(Vector<sbyte> value);

    /// int16_t svlastb[_s16](svbool_t pg, svint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H"
  public static unsafe short ExtractLast(Vector<short> value);

    /// int32_t svlastb[_s32](svbool_t pg, svint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe int ExtractLast(Vector<int> value);

    /// int64_t svlastb[_s64](svbool_t pg, svint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe long ExtractLast(Vector<long> value);

    /// uint8_t svlastb[_u8](svbool_t pg, svuint8_t op) : "LASTB Wresult, Pg, Zop.B" or "LASTB Bresult, Pg, Zop.B"
  public static unsafe byte ExtractLast(Vector<byte> value);

    /// uint16_t svlastb[_u16](svbool_t pg, svuint16_t op) : "LASTB Wresult, Pg, Zop.H" or "LASTB Hresult, Pg, Zop.H"
  public static unsafe ushort ExtractLast(Vector<ushort> value);

    /// uint32_t svlastb[_u32](svbool_t pg, svuint32_t op) : "LASTB Wresult, Pg, Zop.S" or "LASTB Sresult, Pg, Zop.S"
  public static unsafe uint ExtractLast(Vector<uint> value);

    /// uint64_t svlastb[_u64](svbool_t pg, svuint64_t op) : "LASTB Xresult, Pg, Zop.D" or "LASTB Dresult, Pg, Zop.D"
  public static unsafe ulong ExtractLast(Vector<ulong> value);


    /// ExtractVector : Extract vector from pair of vectors

    /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<float> ExtractVector(Vector<float> upper, Vector<float> lower, ulong index);

    /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<double> ExtractVector(Vector<double> upper, Vector<double> lower, ulong index);

    /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<sbyte> ExtractVector(Vector<sbyte> upper, Vector<sbyte> lower, ulong index);

    /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2"
  public static unsafe Vector<short> ExtractVector(Vector<short> upper, Vector<short> lower, ulong index);

    /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<int> ExtractVector(Vector<int> upper, Vector<int> lower, ulong index);

    /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<long> ExtractVector(Vector<long> upper, Vector<long> lower, ulong index);

    /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3"
  public static unsafe Vector<byte> ExtractVector(Vector<byte> upper, Vector<byte> lower, ulong index);

    /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 2"
  public static unsafe Vector<ushort> ExtractVector(Vector<ushort> upper, Vector<ushort> lower, ulong index);

    /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 4"
  public static unsafe Vector<uint> ExtractVector(Vector<uint> upper, Vector<uint> lower, ulong index);

    /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) : "EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8" or "MOVPRFX Zresult, Zop1; EXT Zresult.B, Zresult.B, Zop2.B, #imm3 * 8"
  public static unsafe Vector<ulong> ExtractVector(Vector<ulong> upper, Vector<ulong> lower, ulong index);


    /// FalseMask : Set all predicate elements to false

    /// svbool_t svpfalse[_b]() : "PFALSE Presult.B"
  public static unsafe Vector<byte> FalseMask();


    /// MaskGetFirstSet : Find next active predicate

    /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) : "PNEXT Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<byte> MaskGetFirstSet(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) : "PNEXT Ptied.H, Pg, Ptied.H"
  public static unsafe Vector<ushort> MaskGetFirstSet(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) : "PNEXT Ptied.S, Pg, Ptied.S"
  public static unsafe Vector<uint> MaskGetFirstSet(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) : "PNEXT Ptied.D, Pg, Ptied.D"
  public static unsafe Vector<ulong> MaskGetFirstSet(Vector<ulong> mask, Vector<ulong> from);


    /// MaskSetFirst : Set the first active predicate element to true

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<sbyte> MaskSetFirst(Vector<sbyte> mask, Vector<sbyte> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<short> MaskSetFirst(Vector<short> mask, Vector<short> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<int> MaskSetFirst(Vector<int> mask, Vector<int> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<long> MaskSetFirst(Vector<long> mask, Vector<long> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<byte> MaskSetFirst(Vector<byte> mask, Vector<byte> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<ushort> MaskSetFirst(Vector<ushort> mask, Vector<ushort> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<uint> MaskSetFirst(Vector<uint> mask, Vector<uint> from);

    /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) : "PFIRST Ptied.B, Pg, Ptied.B"
  public static unsafe Vector<ulong> MaskSetFirst(Vector<ulong> mask, Vector<ulong> from);


    /// MaskTestAnyTrue : Test whether any active element is true

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<sbyte> mask, Vector<sbyte> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<short> mask, Vector<short> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<int> mask, Vector<int> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<long> mask, Vector<long> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<byte> mask, Vector<byte> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<ushort> mask, Vector<ushort> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<uint> mask, Vector<uint> from);

    /// bool svptest_any(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestAnyTrue(Vector<ulong> mask, Vector<ulong> from);


    /// MaskTestFirstTrue : Test whether the first active element is true

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<sbyte> mask, Vector<sbyte> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<short> mask, Vector<short> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<int> mask, Vector<int> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<long> mask, Vector<long> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<byte> mask, Vector<byte> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<ushort> mask, Vector<ushort> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<uint> mask, Vector<uint> from);

    /// bool svptest_first(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestFirstTrue(Vector<ulong> mask, Vector<ulong> from);


    /// MaskTestLastTrue : Test whether the last active element is true

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<sbyte> mask, Vector<sbyte> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<short> mask, Vector<short> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<int> mask, Vector<int> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<long> mask, Vector<long> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<byte> mask, Vector<byte> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<ushort> mask, Vector<ushort> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<uint> mask, Vector<uint> from);

    /// bool svptest_last(svbool_t pg, svbool_t op) : PTEST
  public static unsafe bool MaskTestLastTrue(Vector<ulong> mask, Vector<ulong> from);


    /// PropagateBreak : Propagate break to next partition

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<sbyte> PropagateBreak(Vector<sbyte> left, Vector<sbyte> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<short> PropagateBreak(Vector<short> left, Vector<short> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<int> PropagateBreak(Vector<int> left, Vector<int> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<long> PropagateBreak(Vector<long> left, Vector<long> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<byte> PropagateBreak(Vector<byte> left, Vector<byte> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<ushort> PropagateBreak(Vector<ushort> left, Vector<ushort> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<uint> PropagateBreak(Vector<uint> left, Vector<uint> right);

    /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) : "BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B"
  public static unsafe Vector<ulong> PropagateBreak(Vector<ulong> left, Vector<ulong> right);


    /// TrueMask : Set predicate elements to true

    /// svbool_t svptrue_b8() : "PTRUE Presult.B, ALL"
    /// svbool_t svptrue_b16() : "PTRUE Presult.H, ALL"
    /// svbool_t svptrue_b32() : "PTRUE Presult.S, ALL"
    /// svbool_t svptrue_b64() : "PTRUE Presult.D, ALL"
  public static unsafe Vector<byte> TrueMask();

    /// svbool_t svptrue_pat_b8(enum svpattern pattern) : "PTRUE Presult.B, pattern"
    /// svbool_t svptrue_pat_b16(enum svpattern pattern) : "PTRUE Presult.H, pattern"
    /// svbool_t svptrue_pat_b32(enum svpattern pattern) : "PTRUE Presult.S, pattern"
    /// svbool_t svptrue_pat_b64(enum svpattern pattern) : "PTRUE Presult.D, pattern"
  public static unsafe Vector<byte> TrueMask([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All);


  /// total method signatures: 277
  /// total method names:      32
}

@a74nh
Copy link
Contributor Author

a74nh commented Oct 25, 2023 •
edited
Loading 

  /// Optional Entries:
  ///   public static unsafe Vector<float> AbsoluteCompareGreaterThan(Vector<float> left, float right); // svacgt[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareGreaterThan(Vector<double> left, double right); // svacgt[_n_f64]
  ///   public static unsafe Vector<float> AbsoluteCompareGreaterThanOrEqual(Vector<float> left, float right); // svacge[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareGreaterThanOrEqual(Vector<double> left, double right); // svacge[_n_f64]
  ///   public static unsafe Vector<float> AbsoluteCompareLessThan(Vector<float> left, float right); // svaclt[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareLessThan(Vector<double> left, double right); // svaclt[_n_f64]
  ///   public static unsafe Vector<float> AbsoluteCompareLessThanOrEqual(Vector<float> left, float right); // svacle[_n_f32]
  ///   public static unsafe Vector<double> AbsoluteCompareLessThanOrEqual(Vector<double> left, double right); // svacle[_n_f64]
  ///   public static unsafe Vector<float> CompareEqual(Vector<float> left, float right); // svcmpeq[_n_f32]
  ///   public static unsafe Vector<double> CompareEqual(Vector<double> left, double right); // svcmpeq[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, sbyte right); // svcmpeq[_n_s8]
  ///   public static unsafe Vector<short> CompareEqual(Vector<short> left, short right); // svcmpeq[_n_s16]
  ///   public static unsafe Vector<int> CompareEqual(Vector<int> left, int right); // svcmpeq[_n_s32]
  ///   public static unsafe Vector<long> CompareEqual(Vector<long> left, long right); // svcmpeq[_n_s64]
  ///   public static unsafe Vector<byte> CompareEqual(Vector<byte> left, byte right); // svcmpeq[_n_u8]
  ///   public static unsafe Vector<ushort> CompareEqual(Vector<ushort> left, ushort right); // svcmpeq[_n_u16]
  ///   public static unsafe Vector<uint> CompareEqual(Vector<uint> left, uint right); // svcmpeq[_n_u32]
  ///   public static unsafe Vector<ulong> CompareEqual(Vector<ulong> left, ulong right); // svcmpeq[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareEqual(Vector<sbyte> left, long right); // svcmpeq_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareEqual(Vector<short> left, long right); // svcmpeq_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareEqual(Vector<int> left, long right); // svcmpeq_wide[_n_s32]
  ///   public static unsafe Vector<float> CompareGreaterThan(Vector<float> left, float right); // svcmpgt[_n_f32]
  ///   public static unsafe Vector<double> CompareGreaterThan(Vector<double> left, double right); // svcmpgt[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, sbyte right); // svcmpgt[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, short right); // svcmpgt[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, int right); // svcmpgt[_n_s32]
  ///   public static unsafe Vector<long> CompareGreaterThan(Vector<long> left, long right); // svcmpgt[_n_s64]
  ///   public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, byte right); // svcmpgt[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, ushort right); // svcmpgt[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, uint right); // svcmpgt[_n_u32]
  ///   public static unsafe Vector<ulong> CompareGreaterThan(Vector<ulong> left, ulong right); // svcmpgt[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, long right); // svcmpgt_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThan(Vector<short> left, long right); // svcmpgt_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThan(Vector<int> left, long right); // svcmpgt_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareGreaterThan(Vector<byte> left, ulong right); // svcmpgt_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThan(Vector<ushort> left, ulong right); // svcmpgt_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThan(Vector<uint> left, ulong right); // svcmpgt_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareGreaterThanOrEqual(Vector<float> left, float right); // svcmpge[_n_f32]
  ///   public static unsafe Vector<double> CompareGreaterThanOrEqual(Vector<double> left, double right); // svcmpge[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, sbyte right); // svcmpge[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, short right); // svcmpge[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, int right); // svcmpge[_n_s32]
  ///   public static unsafe Vector<long> CompareGreaterThanOrEqual(Vector<long> left, long right); // svcmpge[_n_s64]
  ///   public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, byte right); // svcmpge[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, ushort right); // svcmpge[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, uint right); // svcmpge[_n_u32]
  ///   public static unsafe Vector<ulong> CompareGreaterThanOrEqual(Vector<ulong> left, ulong right); // svcmpge[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, long right); // svcmpge_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareGreaterThanOrEqual(Vector<short> left, long right); // svcmpge_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareGreaterThanOrEqual(Vector<int> left, long right); // svcmpge_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, ulong right); // svcmpge_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, ulong right); // svcmpge_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, ulong right); // svcmpge_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareLessThan(Vector<float> left, float right); // svcmplt[_n_f32]
  ///   public static unsafe Vector<double> CompareLessThan(Vector<double> left, double right); // svcmplt[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, sbyte right); // svcmplt[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThan(Vector<short> left, short right); // svcmplt[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThan(Vector<int> left, int right); // svcmplt[_n_s32]
  ///   public static unsafe Vector<long> CompareLessThan(Vector<long> left, long right); // svcmplt[_n_s64]
  ///   public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, byte right); // svcmplt[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, ushort right); // svcmplt[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, uint right); // svcmplt[_n_u32]
  ///   public static unsafe Vector<ulong> CompareLessThan(Vector<ulong> left, ulong right); // svcmplt[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareLessThan(Vector<sbyte> left, long right); // svcmplt_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThan(Vector<short> left, long right); // svcmplt_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThan(Vector<int> left, long right); // svcmplt_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareLessThan(Vector<byte> left, ulong right); // svcmplt_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThan(Vector<ushort> left, ulong right); // svcmplt_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThan(Vector<uint> left, ulong right); // svcmplt_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareLessThanOrEqual(Vector<float> left, float right); // svcmple[_n_f32]
  ///   public static unsafe Vector<double> CompareLessThanOrEqual(Vector<double> left, double right); // svcmple[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, sbyte right); // svcmple[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, short right); // svcmple[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, int right); // svcmple[_n_s32]
  ///   public static unsafe Vector<long> CompareLessThanOrEqual(Vector<long> left, long right); // svcmple[_n_s64]
  ///   public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, byte right); // svcmple[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, ushort right); // svcmple[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, uint right); // svcmple[_n_u32]
  ///   public static unsafe Vector<ulong> CompareLessThanOrEqual(Vector<ulong> left, ulong right); // svcmple[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, long right); // svcmple_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareLessThanOrEqual(Vector<short> left, long right); // svcmple_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareLessThanOrEqual(Vector<int> left, long right); // svcmple_wide[_n_s32]
  ///   public static unsafe Vector<byte> CompareLessThanOrEqual(Vector<byte> left, ulong right); // svcmple_wide[_n_u8]
  ///   public static unsafe Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, ulong right); // svcmple_wide[_n_u16]
  ///   public static unsafe Vector<uint> CompareLessThanOrEqual(Vector<uint> left, ulong right); // svcmple_wide[_n_u32]
  ///   public static unsafe Vector<float> CompareNotEqualTo(Vector<float> left, float right); // svcmpne[_n_f32]
  ///   public static unsafe Vector<double> CompareNotEqualTo(Vector<double> left, double right); // svcmpne[_n_f64]
  ///   public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, sbyte right); // svcmpne[_n_s8]
  ///   public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, short right); // svcmpne[_n_s16]
  ///   public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, int right); // svcmpne[_n_s32]
  ///   public static unsafe Vector<long> CompareNotEqualTo(Vector<long> left, long right); // svcmpne[_n_s64]
  ///   public static unsafe Vector<byte> CompareNotEqualTo(Vector<byte> left, byte right); // svcmpne[_n_u8]
  ///   public static unsafe Vector<ushort> CompareNotEqualTo(Vector<ushort> left, ushort right); // svcmpne[_n_u16]
  ///   public static unsafe Vector<uint> CompareNotEqualTo(Vector<uint> left, uint right); // svcmpne[_n_u32]
  ///   public static unsafe Vector<ulong> CompareNotEqualTo(Vector<ulong> left, ulong right); // svcmpne[_n_u64]
  ///   public static unsafe Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, long right); // svcmpne_wide[_n_s8]
  ///   public static unsafe Vector<short> CompareNotEqualTo(Vector<short> left, long right); // svcmpne_wide[_n_s16]
  ///   public static unsafe Vector<int> CompareNotEqualTo(Vector<int> left, long right); // svcmpne_wide[_n_s32]
  ///   public static unsafe Vector<float> CompareUnordered(Vector<float> left, float right); // svcmpuo[_n_f32]
  ///   public static unsafe Vector<double> CompareUnordered(Vector<double> left, double right); // svcmpuo[_n_f64]
  ///   public static unsafe float ConditionalExtractAfterLastActiveElement(Vector<float> mask, float fallback, Vector<float> data); // svclasta[_n_f32]
  ///   public static unsafe double ConditionalExtractAfterLastActiveElement(Vector<double> mask, double fallback, Vector<double> data); // svclasta[_n_f64]
  ///   public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, sbyte fallback, Vector<sbyte> data); // svclasta[_n_s8]
  ///   public static unsafe short ConditionalExtractAfterLastActiveElement(Vector<short> mask, short fallback, Vector<short> data); // svclasta[_n_s16]
  ///   public static unsafe int ConditionalExtractAfterLastActiveElement(Vector<int> mask, int fallback, Vector<int> data); // svclasta[_n_s32]
  ///   public static unsafe long ConditionalExtractAfterLastActiveElement(Vector<long> mask, long fallback, Vector<long> data); // svclasta[_n_s64]
  ///   public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector<byte> mask, byte fallback, Vector<byte> data); // svclasta[_n_u8]
  ///   public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, ushort fallback, Vector<ushort> data); // svclasta[_n_u16]
  ///   public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector<uint> mask, uint fallback, Vector<uint> data); // svclasta[_n_u32]
  ///   public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, ulong fallback, Vector<ulong> data); // svclasta[_n_u64]
  ///   public static unsafe float ConditionalExtractLastActiveElement(Vector<float> mask, float fallback, Vector<float> data); // svclastb[_n_f32]
  ///   public static unsafe double ConditionalExtractLastActiveElement(Vector<double> mask, double fallback, Vector<double> data); // svclastb[_n_f64]
  ///   public static unsafe sbyte ConditionalExtractLastActiveElement(Vector<sbyte> mask, sbyte fallback, Vector<sbyte> data); // svclastb[_n_s8]
  ///   public static unsafe short ConditionalExtractLastActiveElement(Vector<short> mask, short fallback, Vector<short> data); // svclastb[_n_s16]
  ///   public static unsafe int ConditionalExtractLastActiveElement(Vector<int> mask, int fallback, Vector<int> data); // svclastb[_n_s32]
  ///   public static unsafe long ConditionalExtractLastActiveElement(Vector<long> mask, long fallback, Vector<long> data); // svclastb[_n_s64]
  ///   public static unsafe byte ConditionalExtractLastActiveElement(Vector<byte> mask, byte fallback, Vector<byte> data); // svclastb[_n_u8]
  ///   public static unsafe ushort ConditionalExtractLastActiveElement(Vector<ushort> mask, ushort fallback, Vector<ushort> data); // svclastb[_n_u16]
  ///   public static unsafe uint ConditionalExtractLastActiveElement(Vector<uint> mask, uint fallback, Vector<uint> data); // svclastb[_n_u32]
  ///   public static unsafe ulong ConditionalExtractLastActiveElement(Vector<ulong> mask, ulong fallback, Vector<ulong> data); // svclastb[_n_u64]
  ///   Total Maybe: 120

  /// Total ACLE covered across API:      427

@a74nh
Copy link
Contributor Author

a74nh commented Oct 25, 2023 •
edited
Loading

This contributes to #93095

It covers instructions in FEAT_SVE related to masks.

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.

@a74nh
Copy link
Contributor Author

a74nh commented Oct 25, 2023

@kunalspathak @tannergooding @BruceForstall @TamarChristinaArm

This was referenced Oct 25, 2023
Closed
Open
@tannergooding tannergooding added the api-suggestion Early API idea and discussion, it is NOT ready for implementation label Oct 26, 2023
@tannergooding tannergooding added this to the 9.0.0 milestone Oct 26, 2023
@ghost ghost removed the untriaged New issue has not been triaged by the area owner label Oct 26, 2023
@tannergooding
Copy link
Member

Break* and While* would benefit from a couple small examples on how they get used. They might benefit from a slightly clearer name like CreateBreak*Mask or CreateWhile*Mask to clarify that these aren't themselves doing the looping or the breaking, but rather simply generating a predicate that can be used given the current index and upper limit. -- They similarly might benefit from consideration on what a cross platform API might look, particularly given the same consideration is needed for AdvSimd or xarch when handling any trailing elements.

CompareEqualTo should just be CompareEqual. Similarly CompareNotEqualTo should be CompareNotEqual

For ConditionalExtractLast I wonder if it would make more sense to be named ConditionalExtractLastActiveElement? Similar comment for CLASTA

For MaskClearAll and MaskSetAll, I wonder if it would make more sense as Vector<T>.TrueMask (equivalent to AllBitsSet) and Vector<T>.FalseMask (equivalent to Zero).

MaskGetFirstSet and MaskSetFirst might benefit from an example showing what they do.

@tannergooding tannergooding added the needs-author-action An issue or pull request that requires more info or actions from the author. label Oct 26, 2023
@ghost
Copy link

ghost commented Oct 26, 2023

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

@a74nh
Copy link
Contributor Author

a74nh commented Nov 1, 2023

For MaskClearAll and MaskSetAll, I wonder if it would make more sense as Vector<T>.TrueMask (equivalent to AllBitsSet) and Vector<T>.FalseMask (equivalent to Zero).

I assume TrueMask() and TrueMask() would still be in the Sve API?

@ghost ghost added needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration and removed needs-author-action An issue or pull request that requires more info or actions from the author. labels Nov 1, 2023
@a74nh
Copy link
Contributor Author

a74nh commented Nov 1, 2023 •
edited
Loading

For MaskSetFirst, MaskGetFirstSet, CreateBreak* and maybe some more in this issue, it doesn't make sense to hide the predicate mask.

For example, matching the Arm instruction:

  public static unsafe Vector<T> MaskSetFirst(Vector<T> mask, Vector<T> select); // PFIRST // predicated

This returns a mask that is a copy of select, with the first active element set to true. Where mask is used to determine the active elements in select.

If mask is made implicit. Then it becomes:

  public static unsafe Vector<T> MaskSetFirst(Vector<T> select); // PFIRST // predicated

This returns a mask that is a copy of select, with the first element set to true.

If the user now writes:

Vector<int> first = Sve.ConditionalSelect(mask, Sve.MaskSetFirst(select), select);

It's now ambiguous if this gives:

  • a copy of select, with the first active element set to true. Where mask is used to determine the active elements in select.
  • a copy of select, with the first element set to true. Then use mask to mask the result, potentially removing the value set by MaskSetFirst.

Maybe for any method which takes in a mask as input in addition to the predicate mask, then the predicate mask should not be made implicit. This stops ambiguity.

@tannergooding
Copy link
Member

Maybe for any method which takes in a mask as input in addition to the predicate mask, then the predicate mask should not be made implicit. This stops ambiguity.

Sounds good to me. It's expected there is a subset of APIs where the mask needs to be explicit for the API to work and make sense.

The goal isn't to strictly remove all explicit masking, just to remove it where it can be trivially achieved via ConditionalSelect instead. For scenarios like this or predicated load/store or adding two masks, having additional functions that make the semantics straightforward and understandable is goodness

@a74nh
Copy link
Contributor Author

a74nh commented Nov 3, 2023

Add some examples. Still need an example for MaskGetFirstSet and maybe some others.

CreateBreakAfterMask() has merging and zeroing variants. We're now exposing the mask for this method. Which means I think we need explicit merging and zeroing methods adding. ie:

  public static unsafe Vector<T> CreateBreakAfterMask(Vector<T> mask, Vector<T> select); // BRKA
  public static unsafe Vector<T> CreateBreakAfterMaskMerging(Vector<T> mask, Vector<T> select,  Vector<T> merge); // BRKA

CreateBreakAfterMask() could be renamed to something like CreateTrueMaskToFirstElement().

Spotted svptest_any and the other tests are missing. I'll add them in.

@a74nh
Copy link
Contributor Author

a74nh commented Nov 3, 2023

Where the second argument is also a mask, I've called that select. That might be a bad idea as it's being highlighted differently:

  public static unsafe Vector<T> CreateBreakAfterMask(Vector<T> mask, Vector<T> select); // BRKA // predicated

Wanted a generic term to indicate a mask that isn't the active selection mask in arg1.

@a74nh
Copy link
Contributor Author

a74nh commented Nov 3, 2023

  • Renamed select arg to from
  • Added TestAnyTrue(), TestFirstTrue(), TestLastTrue()

TrueMask() returns the exact same result regardless of the type of the vector. To avoid bloating the API, we only have Vector<byte> TrueMask(). The user can cast to the correct type. I think this might be wrong.

@a74nh a74nh mentioned this issue Nov 13, 2023
Closed
@tannergooding tannergooding added api-ready-for-review API is ready for review, it is NOT ready for implementation and removed api-suggestion Early API idea and discussion, it is NOT ready for implementation needs-further-triage Issue has been initially triaged, but needs deeper consideration or reconsideration labels Feb 8, 2024
@bartonjs
Copy link
Member

bartonjs commented Feb 8, 2024 •
edited by dotnet-api-review bot
Loading

Video

  • ConditionalExtractAfterLastActiveElement is representing 3 different modes of an underlying instruction, where one is easy to pattern match, but the other two are hard to distinguish, so it's being broken into 3 variants.
  • ConditionalExtractAfterLastActiveElement's fallback parameter should be defaultValue for the scalar input, defaultValues for AndReplicate, and defaultScalar for the vector return to indicate only lane 0 is preserved.
  • The same two points apply to ConditionalExtractLastActiveElement.
  • Review ran out of time on this issue, so the items after ConditionalExtractLastActiveElement need to be moved to a followup issue.
namespace System.Runtime.Intrinsics.Arm;

/// VectorT Summary
public abstract partial class Sve : AdvSimd /// Feature: FEAT_SVE  Category: mask
{
  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThan(Vector<T> left, Vector<T> right); // FACGT // predicated

  /// T: float, double
  public static unsafe Vector<T> AbsoluteCompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FACGE // predicated

  /// T: float, double, int, long, uint, ulong
  public static unsafe Vector<T> Compact(Vector<T> mask, Vector<T> value); // COMPACT

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T> right); // FCMEQ or CMPEQ // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareEqual(Vector<T> left, Vector<T2> right); // CMPEQ // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThan(Vector<T> left, Vector<T2> right); // CMPGT or CMPHI // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareGreaterThanOrEqual(Vector<T> left, Vector<T2> right); // CMPGE or CMPHS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T> right); // FCMGT or CMPGT or CMPHI // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThan(Vector<T> left, Vector<T2> right); // CMPLT or CMPLO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T> right); // FCMGE or CMPGE or CMPHS // predicated

  /// T: [sbyte, long], [short, long], [int, long], [byte, ulong], [ushort, ulong], [uint, ulong]
  public static unsafe Vector<T> CompareLessThanOrEqual(Vector<T> left, Vector<T2> right); // CMPLE or CMPLS // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T> right); // FCMNE or CMPNE // predicated

  /// T: [sbyte, long], [short, long], [int, long]
  public static unsafe Vector<T> CompareNotEqualTo(Vector<T> left, Vector<T2> right); // CMPNE // predicated

  /// T: float, double
  public static unsafe Vector<T> CompareUnordered(Vector<T> left, Vector<T> right); // FCMUO // predicated

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractAfterLastActiveElement(Vector<T> mask, Vector<T> defaultScalar, Vector<T> data); // CLASTA // MOVPRFX
  public static unsafe Vector<T> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<T> mask, Vector<T> defaultValues, Vector<T> data); // CLASTA // MOVPRFX
  public static unsafe T ConditionalExtractAfterLastActiveElement(Vector<T> mask, T defaultValue, Vector<T> data); // CLASTA // MOVPRFX

  /// T: float, double, sbyte, short, int, long, byte, ushort, uint, ulong
  public static unsafe Vector<T> ConditionalExtractLastActiveElement(Vector<T> mask, Vector<T> defaultScalar, Vector<T> data); // CLASTB // MOVPRFX
  public static unsafe Vector<T> ConditionalExtractLastActiveElementAndReplicate(Vector<T> mask, Vector<T> defaultValues, Vector<T> data); // CLASTB // MOVPRFX
  public static unsafe T ConditionalExtractLastActiveElement(Vector<T> mask, T defaultValue, Vector<T> data); // CLASTB // MOVPRFX
}

@bartonjs bartonjs added api-approved API was approved in API review, it can be implemented and removed api-ready-for-review API is ready for review, it is NOT ready for implementation labels Feb 8, 2024
@tannergooding tannergooding mentioned this issue Feb 8, 2024
Open
@a74nh
Copy link
Contributor Author

a74nh commented Feb 19, 2024

Note: Items from this API that were not reviewed/approved are covered in #98184

@kunalspathak kunalspathak mentioned this issue Mar 19, 2024
Closed
@jeffhandley jeffhandley added the arm-sve Work related to arm64 SVE/SVE2 support label Jul 28, 2024
@jeffhandley jeffhandley modified the milestones: 9.0.0, 10.0.0 Jul 28, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
api-approved API was approved in API review, it can be implemented area-System.Runtime.Intrinsics arm-sve Work related to arm64 SVE/SVE2 support
Projects
None yet
Milestone
10.0.0
Development

No branches or pull requests
4 participants
@jeffhandley @a74nh @tannergooding @bartonjs