initial commit

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/TableOfContents.md

@@ -0,0 +1,40 @@
+* [About Burst](index.md)
+* [Getting started](getting-started.md)
+* [C# language support](csharp-language-support.md)
+    * [HPC# overview](csharp-hpc-overview.md)
+    * [Static read-only fields and static constructor support](csharp-static-read-only-support.md)
+    * [String support](csharp-string-support.md)
+    * [Calling Burst compiled code](csharp-calling-burst-code.md)
+    * [Function pointers](csharp-function-pointers.md)
+    * [C#/.NET type support](csharp-type-support.md)
+    * [C#/.NET System namespace support](csharp-system-support.md)
+    * [DllImport and internal calls](csharp-burst-intrinsics-dllimport.md)
+    * [SharedStatic struct](csharp-shared-static.md)
+* [Burst instrinsics](csharp-burst-intrinsics.md)
+    * [Burst intrinsics Common class](csharp-burst-intrinsics-common.md)
+    * [Processor specific SIMD extensions](csharp-burst-intrinsics-processors.md)
+        * [Arm Neon intrinsics reference](csharp-burst-intrinsics-neon.md)
+* [Editor reference](editor-reference-overview.md)
+    * [Burst menu](editor-burst-menu.md)
+    * [Burst Inspector](editor-burst-inspector.md)
+* [Burst compilation](compilation.md)
+    * [Compilation overview](compilation-overview.md)
+    * [Synchronous compilation](compilation-synchronous.md)
+    * [BurstCompile attribute](compilation-burstcompile.md)
+        * [Assembly level BurstCompile](compilation-burstcompile-assembly.md)
+    * [BurstDiscard attribute](compilation-burstdiscard.md)
+    * [Generic jobs](compilation-generic-jobs.md)
+    * [Compilation warnings](compilation-warnings.md)
+* [Building your project](building-projects.md)
+    * [Burst AOT Player Settings reference](building-aot-settings.md)
+* [Optimization](optimization-overview.md)
+    * [Debugging and profiling tools](debugging-profiling-tools.md)
+    * [Loop vectorization optimization](optimization-loop-vectorization.md)
+    * [Memory aliasing](aliasing.md)
+        * [NoAlias attribute](aliasing-noalias.md)
+        * [Aliasing and the job system](aliasing-job-system.md)
+    * [AssumeRange attribute](optimization-assumerange.md)
+    * [Hint intrinsic](optimization-hint.md)
+    * [Constant intrinsic](optimization-constant.md)
+    * [SkipLocalsInit attribute](optimization-skiplocalsinit.md)
+* [Modding support](modding-support.md)

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/aliasing-job-system.md

@@ -0,0 +1,30 @@
+# Aliasing and the job system
+
+Unity's job system infrastructure has some limitations on what can alias within a job struct:
+
+* Structs attributed with [`[NativeContainer]`](https://docs.unity3d.com/ScriptReference/Unity.Collections.LowLevel.Unsafe.NativeContainerAttribute.html) (for example, [`NativeArray`](https://docs.unity3d.com/ScriptReference/Unity.Collections.NativeArray_1.html) and [`NativeSlice`](https://docs.unity3d.com/ScriptReference/Unity.Collections.NativeSlice_1.html)) that are members of a job struct don't alias.
+* Job struct members with the [`[NativeDisableContainerSafetyRestriction]`](https://docs.unity3d.com/ScriptReference/Unity.Collections.LowLevel.Unsafe.NativeDisableContainerSafetyRestrictionAttribute.html) attribute can alias with other members. This is because this attribute explicitly opts in to this kind of aliasing.
+* Pointers to structs attributed with `[NativeContainer]` can't appear in other structs attributed with `[NativeContainer]`. For example, you can't have a `NativeArray<NativeSlice<T>>`. 
+
+The following example job shows how these limitations work in practice:
+
+```c#
+[BurstCompile]
+private struct MyJob : IJob
+{
+    public NativeArray<float> a;
+    public NativeArray<float> b;
+    public NativeSlice<int> c;
+
+    [NativeDisableContainerSafetyRestriction]
+    public NativeArray<byte> d;
+
+    public void Execute() { ... }
+}
+```
+
+* `a`, `b`, and `c` don't alias with each other.
+* `d` can alias with `a`, `b`, or `c`.
+
+>[!TIP]
+>If you're used to working with C/C++'s [Type Based Alias Analysis (TBAA)](https://en.wikipedia.org/wiki/Alias_analysis#Type-based_alias_analysis), then you might assume that because `d` has a different type from `a`, `b`, or `c`, it shouldn't alias. However, in C#, pointers don't have any assumptions that pointing to a different type results in no aliasing. This is why `d` is assumed to alias with `a`, `b`, or `c`. 

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/aliasing-noalias.md

@@ -0,0 +1,357 @@
+# NoAlias attribute
+
+Use the [`[NoAlias]`](xref:Unity.Burst.NoAliasAttribute) attribute to give Burst additional information on the aliasing of pointers and structs. 
+
+In most use cases, you won't need to use the `[NoAlias]` attribute. You don't need to use it with [`[NativeContainer]`](https://docs.unity3d.com/ScriptReference/Unity.Collections.LowLevel.Unsafe.NativeContainerAttribute.html) attributed structs, or with fields in job structs. This is because the Burst compiler infers the no-alias information.
+
+The `[NoAlias]` attribute is exposed so that you can construct complex data structures where Burst can't infer the aliasing. If you use the `[NoAlias]` attribute on a pointer that could alias with another, it might result in undefined behavior and make it hard to track down bugs.
+
+You can use this attribute in the following ways: 
+
+* On a function parameter it signifies that the parameter doesn't alias with any other parameter to the function.
+* On a struct field it signifies that the field doesn't alias with any other field of the struct.
+* On a struct it signifies that the address of the struct can't appear within the struct itself.
+* On a function return value it signifies that the returned pointer doesn't alias with any other pointer returned from the same function.
+
+## NoAlias function parameter
+
+The following is an example of aliasing:
+
+```c#
+int Foo(ref int a, ref int b)
+{
+    b = 13;
+    a = 42;
+    return b;
+}
+```
+
+For this, Burst produces the following assembly:
+
+```x86asm
+mov     dword ptr [rdx], 13
+mov     dword ptr [rcx], 42
+mov     eax, dword ptr [rdx]
+ret
+```
+
+This means that Burst does the following:
+
+* Stores 13 into `b`.
+* Stores 42 into `a`.
+* Reloads the value from `b` to return it.
+
+Burst has to reload `b` because it doesn't know whether `a` and `b` are backed by the same memory or not.
+
+Add the `[NoAlias]` attribute to the code to change this:
+
+```c#
+int Foo([NoAlias] ref int a, ref int b)
+{
+    b = 13;
+    a = 42;
+    return b;
+}
+```
+
+For this, Burst produces the following assembly:
+
+```x86asm
+mov     dword ptr [rdx], 13
+mov     dword ptr [rcx], 42
+mov     eax, 13
+ret
+```
+
+In this case, the load from `b` has been replaced with moving the constant 13 into the return register.
+
+## NoAlias struct field
+
+The following example is the same as the previous, but applied to a struct:
+
+```c#
+struct Bar
+{
+    public NativeArray<int> a;
+    public NativeArray<float> b;
+}
+
+int Foo(ref Bar bar)
+{
+    bar.b[0] = 42.0f;
+    bar.a[0] = 13;
+    return (int)bar.b[0];
+}
+```
+
+For this, Burst produces the following assembly:
+
+```x86asm
+mov     rax, qword ptr [rcx + 16]
+mov     dword ptr [rax], 1109917696
+mov     rcx, qword ptr [rcx]
+mov     dword ptr [rcx], 13
+cvttss2si       eax, dword ptr [rax]
+ret
+```
+
+In this case, Burst does the following:
+
+* Loads the address of the data in `b` into `rax`.
+* Stores 42 into it (`1109917696` is `0x42280000`, which is `42.0f`).
+* Loads the address of the data in `a` into `rcx`.
+* Stores 13 into it.
+* Reloads the data in `b` and converts it to an integer for returning.
+
+If you know that the two `NativeArrays` aren't backed by the same memory, you can change the code to the following:
+
+```c#
+struct Bar
+{
+    [NoAlias]
+    public NativeArray<int> a;
+
+    [NoAlias]
+    public NativeArray<float> b;
+}
+
+int Foo(ref Bar bar)
+{
+    bar.b[0] = 42.0f;
+    bar.a[0] = 13;
+    return (int)bar.b[0];
+}
+```
+
+If you attribute both `a` and `b` with `[NoAlias]` it tells Burst that they don't alias with each other within the struct, which produces the following assembly:
+
+```x86asm
+mov     rax, qword ptr [rcx + 16]
+mov     dword ptr [rax], 1109917696
+mov     rax, qword ptr [rcx]
+mov     dword ptr [rax], 13
+mov     eax, 42
+ret
+```
+
+This means that Burst can return the integer constant 42.
+
+## NoAlias struct
+
+Burst assumes that the pointer to a struct doesn't appear within the struct itself. However, there are cases where this isn't true: 
+
+```c#
+unsafe struct CircularList
+{
+    public CircularList* next;
+
+    public CircularList()
+    {
+        // The 'empty' list just points to itself.
+        next = this;
+    }
+}
+```
+
+Lists are one of the few structures where it's normal to have the pointer to the struct accessible from somewhere within the struct itself.
+
+The following example indicates where `[NoAlias]` on a struct can help:
+
+```c#
+unsafe struct Bar
+{
+    public int i;
+    public void* p;
+}
+
+float Foo(ref Bar bar)
+{
+    *(int*)bar.p = 42;
+    return ((float*)bar.p)[bar.i];
+}
+```
+
+This produces the following assembly:
+
+```x86asm
+mov     rax, qword ptr [rcx + 8]
+mov     dword ptr [rax], 42
+mov     rax, qword ptr [rcx + 8]
+mov     ecx, dword ptr [rcx]
+movss   xmm0, dword ptr [rax + 4*rcx]
+ret
+```
+
+In this case, Burst:
+* Loads `p` into `rax`.
+* Stores 42 into `p`.
+* Loads `p` into `rax` again.
+* Loads `i` into `ecx`.
+* Returns the index into `p` by `i`.
+
+In this situation, Burst loads `p` twice. This is because it doesn't know if `p` points to the address of the struct `bar`. Once it stores 42 into `p` it has to reload the address of `p` from `bar`, which is a costly operation.
+
+Add `[NoAlias]` to prevent this:
+
+```c#
+[NoAlias]
+unsafe struct Bar
+{
+    public int i;
+    public void* p;
+}
+
+float Foo(ref Bar bar)
+{
+    *(int*)bar.p = 42;
+    return ((float*)bar.p)[bar.i];
+}
+```
+
+This produces the following assembly:
+
+```x86asm
+mov     rax, qword ptr [rcx + 8]
+mov     dword ptr [rax], 42
+mov     ecx, dword ptr [rcx]
+movss   xmm0, dword ptr [rax + 4*rcx]
+ret
+```
+
+In this situation, Burst only loads the address of `p` once, because `[NoAlias]` tells it that `p` can't be the pointer to `bar`.
+
+## NoAlias function return
+
+Some functions can only return a unique pointer. For instance, `malloc` only returns a unique pointer. In this case, `[return:NoAlias]` gives some useful information to Burst.
+
+>[!IMPORTANT]
+>Only use `[return: NoAlias]` on functions that are guaranteed to produce a unique pointer. For example, with bump-allocations, or with things like `malloc`. Burst aggressively inlines functions for performance considerations, so with small functions, Burst inlines them into their parents to produce the same result without the attribute.
+
+The following example uses a bump allocator backed with a stack allocation:
+
+```c#
+// Only ever returns a unique address into the stackalloc'ed memory.
+// We've made this no-inline because Burst will always try and inline
+// small functions like these, which would defeat the purpose of this
+// example
+[MethodImpl(MethodImplOptions.NoInlining)]
+unsafe int* BumpAlloc(int* alloca)
+{
+    int location = alloca[0]++;
+    return alloca + location;
+}
+
+unsafe int Func()
+{
+    int* alloca = stackalloc int[128];
+
+    // Store our size at the start of the alloca.
+    alloca[0] = 1;
+
+    int* ptr1 = BumpAlloc(alloca);
+    int* ptr2 = BumpAlloc(alloca);
+
+    *ptr1 = 42;
+    *ptr2 = 13;
+
+    return *ptr1;
+}
+```
+
+This produces the following assembly:
+
+```x86asm
+push    rsi
+push    rdi
+push    rbx
+sub     rsp, 544
+lea     rcx, [rsp + 36]
+movabs  rax, offset memset
+mov     r8d, 508
+xor     edx, edx
+call    rax
+mov     dword ptr [rsp + 32], 1
+movabs  rbx, offset "BumpAlloc(int* alloca)"
+lea     rsi, [rsp + 32]
+mov     rcx, rsi
+call    rbx
+mov     rdi, rax
+mov     rcx, rsi
+call    rbx
+mov     dword ptr [rdi], 42
+mov     dword ptr [rax], 13
+mov     eax, dword ptr [rdi]
+add     rsp, 544
+pop     rbx
+pop     rdi
+pop     rsi
+ret
+```
+
+The key things that Burst does:
+
+* Has `ptr1` in `rdi`.
+* Has `ptr2` in `rax`.
+* Stores 42 into `ptr1`.
+* Stores 13 into `ptr2`.
+* Loads `ptr1` again to return it.
+
+If you add the `[return: NoAlias]` attribute:
+
+```c#
+[MethodImpl(MethodImplOptions.NoInlining)]
+[return: NoAlias]
+unsafe int* BumpAlloc(int* alloca)
+{
+    int location = alloca[0]++;
+    return alloca + location;
+}
+
+unsafe int Func()
+{
+    int* alloca = stackalloc int[128];
+
+    // Store our size at the start of the alloca.
+    alloca[0] = 1;
+
+    int* ptr1 = BumpAlloc(alloca);
+    int* ptr2 = BumpAlloc(alloca);
+
+    *ptr1 = 42;
+    *ptr2 = 13;
+
+    return *ptr1;
+}
+```
+
+It produces the following assembly:
+
+```x86asm
+push    rsi
+push    rdi
+push    rbx
+sub     rsp, 544
+lea     rcx, [rsp + 36]
+movabs  rax, offset memset
+mov     r8d, 508
+xor     edx, edx
+call    rax
+mov     dword ptr [rsp + 32], 1
+movabs  rbx, offset "BumpAlloc(int* alloca)"
+lea     rsi, [rsp + 32]
+mov     rcx, rsi
+call    rbx
+mov     rdi, rax
+mov     rcx, rsi
+call    rbx
+mov     dword ptr [rdi], 42
+mov     dword ptr [rax], 13
+mov     eax, 42
+add     rsp, 544
+pop     rbx
+pop     rdi
+pop     rsi
+ret
+```
+
+In this case, Burst doesn't reload `ptr2`, and moves 42 into the return register.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/aliasing.md

@@ -0,0 +1,174 @@
+# Memory aliasing
+
+Memory aliasing is a way to tell Burst how your code uses data. This can improve and optimize the performance of your application.
+
+Memory aliasing happens when locations in the memory overlap each other. The following documentation outlines the difference between memory aliasing, and no memory aliasing.  
+
+The following example shows a job that copies data from an input array to an output array:
+
+```c#
+[BurstCompile]
+private struct CopyJob : IJob
+{
+    [ReadOnly]
+    public NativeArray<float> Input;
+
+    [WriteOnly]
+    public NativeArray<float> Output;
+
+    public void Execute()
+    {
+        for (int i = 0; i < Input.Length; i++)
+        {
+            Output[i] = Input[i];
+        }
+    }
+}
+```
+## No memory aliasing
+
+If the arrays `Input` and `Output` don't overlap, which means that their respective memory location doesn't overlap, the code returns the following result after running this job on a sample input/output:
+
+![](images/burst-noalias.png)</br>_Memory with no aliasing_
+
+If Burst is [noalias](aliasing-noalias.md) aware, it can work at the scalar level to optimize the previous scalar loop. It does this through a process called vectorizing, where it rewrites the loop to process elements in a small batch. For example, Burst could work at vector level in 4 by 4 elements: 
+
+![](images/burst-noalias-vectorized.png)<br/>_Memory with no aliasing vectorized_
+
+## Memory aliasing
+
+If the `Output` array overlaps the `Input` array by one element (for example `Output[0]` points to `Input[1]`), then this means that the memory is aliasing. This gives the following result when you run `CopyJob` without the auto vectorizer:
+
+![Memory with aliasing](images/burst-alias.png)<br>_Memory with aliasing_
+
+If [Burst isn't aware of the memory aliasing](aliasing-noalias.md), it tries to auto vectorize the loop, which results in the following:
+
+![](images/burst-alias-vectorized.png)<br/>_Memory with aliasing and invalid vectorized code_
+
+The result of this code is invalid and might lead to bugs if Burst can't identify them.
+
+## Generated code
+
+In the `CopyJob` example, there is an `x64` assembly targeted at `AVX2` in its loop. The instruction `vmovups` moves 8 floats, so a single auto vectorized loop moves 4 × 8 floats, which equals 32 floats copied per loop iteration, instead of just one:
+
+```x86asm
+.LBB0_4:
+    vmovups ymm0, ymmword ptr [rcx - 96]
+    vmovups ymm1, ymmword ptr [rcx - 64]
+    vmovups ymm2, ymmword ptr [rcx - 32]
+    vmovups ymm3, ymmword ptr [rcx]
+    vmovups ymmword ptr [rdx - 96], ymm0
+    vmovups ymmword ptr [rdx - 64], ymm1
+    vmovups ymmword ptr [rdx - 32], ymm2
+    vmovups ymmword ptr [rdx], ymm3
+    sub     rdx, -128
+    sub     rcx, -128
+    add     rsi, -32
+    jne     .LBB0_4
+    test    r10d, r10d
+    je      .LBB0_8
+```
+
+The following example shows the same Burst compiled loop, but Burst's aliasing is artificially disabled: 
+
+```x86asm
+.LBB0_2:
+    mov     r8, qword ptr [rcx]
+    mov     rdx, qword ptr [rcx + 16]
+    cdqe
+    mov     edx, dword ptr [rdx + 4*rax]
+    mov     dword ptr [r8 + 4*rax], edx
+    inc     eax
+    cmp     eax, dword ptr [rcx + 8]
+    jl      .LBB0_2
+```
+
+The result is entirely scalar and runs approximately 32 times slower than the highly optimized, vectorized variant that the original alias analysis produces.
+
+## Function cloning
+
+For function calls where Burst knows about the aliasing between parameters to the function, Burst can infer the aliasing. It can then propagate this onto the called function to improve optimization:
+
+```c#
+[MethodImpl(MethodImplOptions.NoInlining)]
+int Bar(ref int a, ref int b)
+{
+    a = 42;
+    b = 13;
+    return a;
+}
+
+int Foo()
+{
+    var a = 53;
+    var b = -2;
+
+    return Bar(ref a, ref b);
+}
+```
+
+The assembly for `Bar` would be:
+
+```x86asm
+mov     dword ptr [rcx], 42
+mov     dword ptr [rdx], 13
+mov     eax, dword ptr [rcx]
+ret
+```
+
+This is because Burst doesn't know the aliasing of `a` and `b` within the `Bar` function. This is in line with what other compiler technologies do with this code snippet.
+
+Burst is smarter than this though. Through a process of function cloning, Burst creates a copy of `Bar` where it knows that the aliasing properties of `a` and `b` don't alias. It then replaces the original call to `Bar` with a call to the copy. This results in the following assembly:
+
+```x86asm
+mov     dword ptr [rcx], 42
+mov     dword ptr [rdx], 13
+mov     eax, 42
+ret
+```
+
+In this scenario, Burst doesn't perform the second load from `a`.
+
+## Aliasing checks
+
+Because aliasing is key to Burst's ability to optimize for performance, there are some aliasing intrinsics:
+
+- [`Unity.Burst.CompilerServices.Aliasing.ExpectAliased`](xref:Unity.Burst.CompilerServices.Aliasing.ExpectAliased*) expects that the two pointers do alias, and generates a compiler error if not.
+- [`Unity.Burst.CompilerServices.Aliasing.ExpectNotAliased`](xref:Unity.Burst.CompilerServices.Aliasing.ExpectNotAliased*) expects that the two pointers don't alias, and generates a compiler error if not.
+
+An example:
+
+```c#
+using static Unity.Burst.CompilerServices.Aliasing;
+
+[BurstCompile]
+private struct CopyJob : IJob
+{
+    [ReadOnly]
+    public NativeArray<float> Input;
+
+    [WriteOnly]
+    public NativeArray<float> Output;
+
+    public unsafe void Execute()
+    {
+        // NativeContainer attributed structs (like NativeArray) cannot alias with each other in a job struct!
+        ExpectNotAliased(Input.getUnsafePtr(), Output.getUnsafePtr());
+
+        // NativeContainer structs cannot appear in other NativeContainer structs.
+        ExpectNotAliased(in Input, in Output);
+        ExpectNotAliased(in Input, Input.getUnsafePtr());
+        ExpectNotAliased(in Input, Output.getUnsafePtr());
+        ExpectNotAliased(in Output, Input.getUnsafePtr());
+        ExpectNotAliased(in Output, Output.getUnsafePtr());
+
+        // But things definitely alias with themselves!
+        ExpectAliased(in Input, in Input);
+        ExpectAliased(Input.getUnsafePtr(), Input.getUnsafePtr());
+        ExpectAliased(in Output, in Output);
+        ExpectAliased(Output.getUnsafePtr(), Output.getUnsafePtr());
+    }
+}
+```
+
+These checks only run when optimizations are enabled, because proper aliasing deduction is intrinsically linked to the optimizer's ability to see through functions via inlining.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/building-aot-settings.md

@@ -0,0 +1,39 @@
+# Burst AOT Player Settings reference
+
+To control Burst's AOT compilation, use the [Player Settings window](https://docs.unity3d.com/Manual/class-PlayerSettings.html) (**Edit > Player Settings > Burst AOT Settings**). These settings override the Burst settings in the [Jobs menu](editor-burst-menu.md) when you make a build of your project.
+
+![Burst AOT Settings](images/burst_aot_settings.png)
+
+|**Setting**|**Function**|
+|---|---|
+|**Target Platform**| Displays the current platform. To change the platform, go to **File > Build Settings**. You can set these Player Settings per platform.|
+|**Enable Burst Compilation**| Enable this setting to turn Burst compilation on. Disable this setting to deactivate Burst compilation for the selected platform.|
+|**Enable Optimizations**| Enable this setting to activate Burst optimizations.|
+|**Force Debug Information**| Enable this setting to make Burst generate debug information. This adds debug symbols to your project, even in release builds of your project, so that when you load it in a debugger you can see file and line information.|
+|**Use Platform SDK Linker**<br/>(Windows, macOS, and Linux builds only)| Disables cross compilation support. When you enable this setting, you must use platform-specific tools for your target platform. Only enable this setting for debugging purposes. For more information, see [Platforms with cross compilation disabled](building-projects.md#cross-compilation).|
+|**Target 32Bit CPU Architectures**<br/>(Displayed if the architecture is supported)| Select the CPU architectures that you want to use for 32 bit builds. By default, SSE2 and SSE4 are selected.|
+|**Target 64Bit CPU Architectures**<br/>(Displayed if the architecture is supported)| Select the CPU architectures that you want to use for 64-bit builds. By default, SSE2 and SSE4 are selected.|
+|**Target Arm 64Bit CPU Architectures**<br/>(Displayed if the architecture is supported)| Select the CPU architectures that you want to use for Arm 64-bit builds. By default, ARMV8A is selected.|
+|**Optimize For**| Select which optimization settings to compile Burst code for. For more information see [`OptimizeFor`](xref:Unity.Burst.OptimizeFor).|
+|Performance|Optimizes the job to run as fast as possible.|
+|Size|Optimizes to make the code generation as small as possible.|
+|Fast Compilation|Compiles code as fast as possible, with minimal optimization. Burst doesn't perform any  vectorization, inlining, or loop optimizations. |
+|Balanced</br>(Default)|Optimizes for code that runs fast but keeps compile time as low as possible.|
+|**Disabled Warnings**| Specify a semi-colon separated list of Burst warning numbers to disable the warnings for a player build. Unity shares this setting across all platforms. This can be useful if you want to ignore specific [compilation warnings](compilation-warnings.md) while testing your application. |
+
+The **CPU Architecture** setting is only supported for Windows, macOS, Linux and Android. Unity builds a Player that supports the CPU architectures you've selected. Burst generates a special dispatch into the module, so that the code generated detects the CPU the target platform uses and selects the appropriate CPU architecture at runtime.
+
+## Optimize For setting
+
+>[!NOTE]
+>Any [OptimizeFor](xref:Unity.Burst.OptimizeFor) setting is the global default optimization setting for any Burst job or function-pointer. If any assembly level `BurstCompile`, or a specific Burst job or function-pointer has an `OptimizeFor` setting, it overrides the global optimization setting for those jobs.
+
+To control how Burst optimizes your code, use the **Optimize For** setting in the Editor, or use the [`OptimizeFor`](xref:Unity.Burst.OptimizeFor) field:
+
+```c#
+[BurstCompile(OptimizeFor = OptimizeFor.FastCompilation)]
+public struct MyJob : IJob
+{
+    // ...
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/building-projects.md

@@ -0,0 +1,68 @@
+# Building your project
+
+When you build your project, Burst compiles your code, then creates a single dynamic library, and puts it into the Plugins folder for the platform you're targeting. For example, on Windows, the path is `Data/Plugins/lib_burst_generated.dll`. 
+
+>[!NOTE]
+>This is different if your target platform is iOS. Instead, Unity generates a static library because of Apple's submission requirements for TestFlight.
+
+The job system runtime loads the generated library the first time a Burst compiled method is invoked. 
+
+To control Burst's AOT compilation, use the settings in the **Burst AOT Settings** section of the Player Settings window (**Edit > Player Settings > Burst AOT Settings**). For more information, see [Burst AOT Settings reference](building-aot-settings.md).
+
+<a name="cross-compilation"></a>
+
+## Platforms without cross compilation
+
+If you're compiling for a non-desktop platform, then Burst compilation requires specific platform compilation tools (similar to [IL2CPP](https://docs.unity3d.com/Manual/IL2CPP.html)). By default, desktop platforms (macOS, Linux, Windows) don't need external toolchain support, unless you enable the **Use Platform SDK Linker** setting in the [Burst AOT Settings](building-aot-settings.md). 
+
+The table below lists the level of support for AOT compilation on each platform. If you select an invalid target (one with missing tools, or unsupported), Unity doesn't use Burst compilation, which might lead it to fail, but Unity still builds the target without Burst optimizations. 
+
+>[!NOTE]
+>Burst supports cross-compilation between desktop platforms (macOS/Linux/Windows) by default.
+
+| **Host Editor platform** | **Target Player platform** | **Supported CPU architectures** | **External toolchain requirements** |
+|---|---|---|---|
+| Windows | Windows | x86 (SSE2, SSE4)<br/> x64 (SSE2, SSE4, AVX, AVX2) | None |
+| Windows | Universal Windows Platform | x86 (SSE2, SSE4)<br/> x64 (SSE2, SSE4, AVX, AVX2)<br/>ARM32 (Thumb2, Neon32)<br/>ARMV8 AARCH64<br/><br/>**Note:** A UWP build always compiles all four targets.| Visual Studio 2017<br/>Universal Windows Platform Development Workflow<br/>C++ Universal Platform Tools |
+| Windows | Android | x86 SSE2<br/> ARMV7 (Thumb2, Neon32)<br/> ARMV8 AARCH64 (ARMV8A, ARMV8A_HALFFP, ARMV9A) | Android NDK<br/><br/>**Important:** Use the Android NDK that you install through Unity Hub (via **Add Component**). Burst falls back to the one that the `ANDROID_NDK_ROOT` environment variable specifies if the Unity external tools settings aren't configured. |
+| Windows | Magic Leap | ARMV8 AARCH64 | You must install the Lumin SDK via the Magic Leap Package Manager and configured in the Unity Editor's External Tools Preferences. |
+| Windows | Xbox One | x64 SSE4 | Microsoft GDK |
+| Windows | Xbox Series | x64 AVX2 | Microsoft GDK |
+| Windows | PlayStation 4 | x64 SSE4 | Minimum PS4 SDK version 8.00 |
+| Windows | PlayStation 5 | x64 AVX2 | Minimum PS5 SDK version 2.00 |
+| Windows | Nintendo Switch | ARMV8 AARCH64 | None |
+| macOS | macOS | x64 (SSE2, SSE4, AVX, AVX2), Apple Silicon | None |
+| macOS | iOS | ARM32 Thumb2/Neon32, ARMV8 AARCH64 | Xcode with command line tools installed (`xcode-select --install`) |
+| macOS | Android | x86 SSE2<br/> ARMV7 (Thumb2, Neon32)<br/> ARMV8 AARCH64 (ARMV8A, ARMV8A_HALFFP, ARMV9A) | Android NDK<br/><br/>**Important:** Use the Android NDK that you install through Unity Hub (via **Add Component**). Burst falls back to the one that the `ANDROID_NDK_ROOT` environment variable specifies if the Unity external tools settings aren't configured. |
+| macOS | Magic Leap | ARMV8 AARCH64 | You must install the Lumin SDK via the Magic Leap Package Manager and configured in the Unity Editor's External Tools Preferences. |
+| Linux | Linux | x64 (SSE2, SSE4, AVX, AVX2) | None |
+
+The maximum target CPU is hardcoded per platform. For standalone builds that target desktop platforms (Windows/Linux/macOS) you can choose the supported targets via the [Burst AOT Settings](building-aot-settings.md)
+
+### Projects that don't use Burst
+
+Some projects can't use Burst as the compiler:
+
+* iOS projects from the Windows Editor
+* Android projects from the Linux Editor
+* Xcode projects generated from the **Create Xcode Project** option
+
+## Multiple Burst targets
+
+When Burst compiles multiple target platforms during a build, it has to perform separate compilations. For example, if you want to compile `X64_SSE2` and `X64_SSE4`, the Burst has to do two separate compilations to generate code for each of the targets you choose.
+
+To keep the combinations of targets to a minimum, Burst target platforms require multiple processor instruction sets underneath:
+
+* `SSE4.2` is gated on having `SSE4.2` and `POPCNT` instruction sets.
+* `AVX2` is gated on having `AVX2`, `FMA`, `F16C`, `BMI1`, and `BMI2` instruction sets.
+* `ARMV8A` is a basic Armv8-A CPU target
+* `ARMV8A_HALFFP` is `ARMV8A` plus the following extensions: `fullfp16`, `dotprod`, `crypto`, `crc`, `rdm`, `lse`. In practice, this means Cortex A75/A55 and later cores.
+* `ARMV9A` is `ARMV8A_HALFFP` plus SVE2 support. In practice, this means Cortex X2/A710/A510 and later cores. **Important:** this target is currently experimental.
+
+## Dynamic dispatch based on runtime CPU features 
+
+For all `x86`/`x64` CPU desktop platforms, as well as for 64-bit Arm on Android, Burst takes into account the CPU features available at runtime to dispatch jobs to different versions it compiles.
+
+For `x86` and `x64` CPUs, Burst supports `SSE2` and `SSE4` instruction sets at runtime only. 
+
+For example, with dynamic CPU dispatch, if your CPU supports `SSE3` and below, Burst selects `SSE2` automatically.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-burstcompile-assembly.md

@@ -0,0 +1,41 @@
+# Assembly level BurstCompile
+
+Use the `BurstCompile` attribute on an assembly to set options for all Burst jobs and function-pointers within the assembly:
+
+```c#
+[assembly: BurstCompile(CompileSynchronously = true)]
+```
+
+For example, if an assembly just contains game code which needs to run quickly, you can use:
+
+```c#
+[assembly: BurstCompile(OptimizeFor = OptimizeFor.FastCompilation)]
+```
+
+This means that Burst compiles the code as fast as it possibly can, which means that you can iterate on the game code much more quickly. It also means that other assemblies compile as they did before, which gives you more control on how Burst works with your code.
+
+Assembly-level `BurstCompile` attributes iterate with any job or function-pointer attribute, and also with any globally set options from the Burst Editor menu. Burst prioritizes assembly level attributes in the following order:
+
+1. [Editor menu settings](editor-burst-menu.md) take precedence. For example, if you enable **Native Debug Compilation** from the Burst menu, Burst always compiles your code ready for debugging. 
+1. Burst checks any `BurstCompile` attribute on a job or function-pointer. If you have `CompileSynchronously = true` in `BurstCompile`, then Burst compiles synchronously
+1. Otherwise, Burst sources any remaining settings from any assembly level attribute.
+
+For example:
+
+```c#
+[assembly: BurstCompile(OptimizeFor = OptimizeFor.FastCompilation)]
+
+// This job will be optimized for fast-compilation, because the per-assembly BurstCompile asked for it
+[BurstCompile]
+struct AJob : IJob
+{
+    // ...
+}
+
+// This job will be optimized for size, because the per-job BurstCompile asked for it
+[BurstCompile(OptimizeFor = OptimizeFor.Size)]
+struct BJob : IJob
+{
+    // ...
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-burstcompile.md

@@ -0,0 +1,55 @@
+# BurstCompile attribute
+
+To improve the performance of Burst, you can change how it behaves when it compiles a job with the [`[BurstCompile]`](xref:Unity.Burst.BurstCompileAttribute) attribute. Use it do the following: 
+
+* Use a different accuracy for math functions (for example, sin, cos).
+* Relax the order of math computations so that Burst can rearrange the floating point calculations.
+* Force a synchronous compilation of a job (only for [just-in-time compilation](compilation.md)).
+
+For example, you can use the `[BurstCompile]` attribute to change the [floating precision](xref:Unity.Burst.FloatPrecision) and [float mode](xref:Unity.Burst.FloatMode) of Burst like so: 
+
+    [BurstCompile(FloatPrecision.Med, FloatMode.Fast)]
+
+## FloatPrecision
+
+Use the [`FloatPrecision`](xref:Unity.Burst.FloatPrecision) enumeration to define Burst's floating precision accuracy.
+
+Float precision is measured in ulp (unit in the last place or unit of least precision). This is the space between floating-point numbers: the value the least significant digit represents if it's 1. `Unity.Burst.FloatPrecision` provides the following accuracy: 
+
+* `FloatPrecision.Standard`: Default value, which is the same as `FloatPrecision.Medium`. This provides an accuracy of 3.5 ulp. 
+* `FloatPrecision.High`: Provides an accuracy of 1.0 ulp.
+* `FloatPrecision.Medium`: Provides an accuracy of 3.5 ulp.
+* `FloatPrecision.Low`: Has an accuracy defined per function, and functions might specify a restricted range of valid inputs.
+
+**Note:** In previous versions of the Burst API, the `FloatPrecision` enum was named `Accuracy`.
+
+### FloatPrecision.Low
+
+If you use the [`FloatPrecision.Low`](xref:Unity.Burst.FloatPrecision) mode, the following functions have a precision of 350.0 ulp. All other functions inherit the ulp from `FloatPrecision.Medium`.
+
+* `Unity.Mathematics.math.sin(x)`
+* `Unity.Mathematics.math.cos(x)`
+* `Unity.Mathematics.math.exp(x)`
+* `Unity.Mathematics.math.exp2(x)`	
+* `Unity.Mathematics.math.exp10(x)`	
+* `Unity.Mathematics.math.log(x)`
+* `Unity.Mathematics.math.log2(x)`
+* `Unity.Mathematics.math.log10(x)`	
+* `Unity.Mathematics.math.pow(x, y)`
+    * Negative `x` to the power of a fractional `y` aren't supported.
+* `Unity.Mathematics.math.fmod(x, y)`
+
+## FloatMode
+
+Use the [`FloatMode`](xref:Unity.Burst.FloatMode) enumeration to define Burst's floating point math mode. It provides the following modes:
+
+
+* `FloatMode.Default`: Defaults to `FloatMode.Strict` mode.
+* `FloatMode.Strict`: Burst doesn't perform any re-arrangement of the calculation and respects special floating point values (such as denormals, NaN). This is the default value.
+* `FloatMode.Fast`: Burst can perform instruction re-arrangement and use dedicated or less precise hardware SIMD instructions.
+* `FloatMode.Deterministic`: Unsupported. Deterministic mode is reserved for a future iteration of Burst. 
+
+For hardware that can support Multiply and Add (e.g mad `a * b + c`) into a single instruction, you can use `FloatMode.Fast` to enable this optimization. However, the reordering of these instructions might lead to a lower accuracy.
+
+Use `FloatMode.Fast` for scenarios where the exact order of the calculation and the uniform handling of NaN values aren't required.
+

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-burstdiscard.md

@@ -0,0 +1,40 @@
+# BurstDiscard attribute
+
+If you're running C# code not inside Burst-compiled code, you might want to use managed objects, but not compile these portions of code within Burst. To do this, use the `[BurstDiscard]` attribute on a method:
+
+```c#
+[BurstCompile]
+public struct MyJob : IJob
+{
+    public void Execute()
+    {
+        // Only executed when running from a full .NET runtime
+        // this method call will be discard when compiling this job with
+        // [BurstCompile] attribute
+        MethodToDiscard();
+    }
+
+    [BurstDiscard]
+    private static void MethodToDiscard(int arg)
+    {
+        Debug.Log($"This is a test: {arg}");
+    }
+}
+```
+>[!NOTE]
+>A method with `[BurstDiscard]` can't have a return value.
+
+You can use a `ref` or `out` parameter, which indicates whether the code is running on Burst or managed:
+
+```c#
+[BurstDiscard]
+private static void SetIfManaged(ref bool b) => b = false;
+
+private static bool IsBurst()
+{
+    var b = true;
+    SetIfManaged(ref b);
+    return b;
+}
+```
+

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-generic-jobs.md

@@ -0,0 +1,102 @@
+# Generic jobs
+
+Burst compiles a job in two ways:
+
+* In the Editor, it compiles the job when it's scheduled, known as just-in-time (JIT) compilation.
+* In a player build, it compiles the job as part of the built player, known as ahead-of-time (AOT) compilation.
+
+For more information, see the documentation on [Compilation](compilation-overview.md).
+
+If the job is a concrete type (doesn't use generics), Burst compiles it in both modes (AOT and JIT). However, a generic job might behave in an unexpected way.
+
+While Burst supports generics, it has limited support for generic jobs or function pointers. If you notice that a job scheduled in the Editor is running at full speed, but not in a built player, it's might be a problem related to generic jobs.
+
+The following example defines a generic job:
+
+```c#
+// Direct generic job
+[BurstCompile]
+struct MyGenericJob<TData> : IJob where TData : struct { 
+    public void Execute() { ... }
+}
+```
+
+You can also nest generic jobs: 
+
+```c#
+// Nested generic job
+public class MyGenericSystem<TData> where TData : struct {
+    [BurstCompile]
+    struct MyGenericJob  : IJob { 
+        public void Execute() { ... }
+    }
+
+    public void Run()
+    {
+        var myJob = new MyGenericJob(); // implicitly MyGenericSystem<TData>.MyGenericJob
+        myJob.Schedule();    
+    }
+}
+```
+
+Jobs that aren't Burst compiled look like this:
+
+```c#
+// Direct Generic Job
+var myJob = new MyGenericJob<int>();
+myJob.Schedule();
+
+// Nested Generic Job
+var myJobSystem = new MyGenericSystem<float>();
+myJobSystem.Run();
+```
+
+In both cases, in a player build, the Burst compiler detects that it has to compile `MyGenericJob<int>` and `MyGenericJob<float>`. This is because the generic jobs (or the type surrounding it for the nested job) are used with fully resolved generic arguments (`int` and `float`).
+
+However, if these jobs are used indirectly through a generic parameter, the Burst compiler can't detect the jobs it has to compile at player build time:
+
+```c#
+public static void GenericJobSchedule<TData>() where TData: struct {
+    // Generic argument: Generic Parameter TData
+    // This Job won't be detected by the Burst Compiler at standalone-player build time.
+    var job = new MyGenericJob<TData>();
+    job.Schedule();
+}
+
+// The implicit MyGenericJob<int> will run at Editor time in full Burst speed
+// but won't be detected at standalone-player build time.
+GenericJobSchedule<int>();
+```
+
+The same restriction applies if you declare the job in the context of generic parameter that comes from a type:
+
+```c#
+// Generic Parameter TData
+public class SuperJobSystem<TData>
+{
+    // Generic argument: Generic Parameter TData
+    // This Job won't be detected by the Burst Compiler at standalone-player build time.
+    public MyGenericJob<TData> MyJob;
+}
+```
+
+If you want to use generic jobs, you must use them directly with fully resolved generic arguments (for example, `int`, `MyOtherStruct`). You can't use them with a generic parameter indirection (for example, `MyGenericJob<TContext>`).
+
+>[!IMPORTANT]
+>Burst doesn't support scheduling generic Jobs through generic methods. While this works in the Editor, it doesn't work in the standalone player.
+
+## Function pointers
+
+Function pointers are restricted because you can't use a generic delegate through a function pointer with Burst:
+
+```c#
+public delegate void MyGenericDelegate<T>(ref TData data) where TData: struct;
+
+var myGenericDelegate = new MyGenericDelegate<int>(MyIntDelegateImpl);
+// Will fail to compile this function pointer.
+var myGenericFunctionPointer = BurstCompiler.CompileFunctionPointer<MyGenericDelegate<int>>(myGenericDelegate);
+```
+
+This limitation is because of a limitation of the .NET runtime to interop with such delegates.
+
+For more information, see the documentation on [Function pointers](csharp-function-pointers.md).

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-overview.md

@@ -0,0 +1,21 @@
+# Compilation overview
+
+Burst compiles your code in different ways depending on its context.
+
+* In Play mode, Burst compiles your code [just-in-time (JIT)](https://en.wikipedia.org/wiki/Just-in-time_compilation). 
+* When you build and run your application to a player, Burst compiles [ahead-of-time (AOT)](https://en.wikipedia.org/wiki/Ahead-of-time_compilation).
+
+## Just-in-time compilation
+
+While your application is in Play mode in the Editor, Burst compiles your code asynchronously at the point that Unity uses it. This means that your code runs under the default [Mono compiler](https://docs.unity3d.com/Manual/Mono.html) until Burst completes its work in the background. 
+
+To force Unity to compile your code synchronously while in the Editor, see [Synchronous compilation](compilation-synchronous.md)
+
+## Ahead-of-time compilation
+
+When you build your project, Burst compiles all the supported code ahead-of-time (AOT) into a native library which Unity ships with your application. To control how Burst compiles AOT, use the [Player Settings window](building-aot-settings.md). Depending on the platform you want to build for, AOT compilation might require access to linker tools. For more information, see [Building your project](building-projects.md).
+
+## Further resources
+
+* [Synchronous compilation](compilation-synchronous.md)
+* [BurstCompile attribute](compilation-burstcompile.md)

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-synchronous.md

@@ -0,0 +1,21 @@
+# Synchronous compilation
+
+By default, when in Play mode, the Burst compiler compiles jobs asynchronously. To force synchronous compilation, set the [`CompileSynchronously`](xref:Unity.Burst.BurstCompileAttribute.CompileSynchronously) property to `true`, which compiles your method on the first schedule.
+
+```c#
+[BurstCompile(CompileSynchronously = true)]
+public struct MyJob : IJob
+{
+    // ...
+}
+```
+
+If you don't set this property, on the first call of a job, Burst compiles it asynchronously in the background, and runs a managed C# job in the mean time. This minimizes any frame hitching and keeps the experience responsive.
+
+However, when you set `CompileSynchronously = true`, no asynchronous compilation can happen. This means that it might take longer for Burst to compile. This pause for compilation affects the current running frame, which means that hitches can happen and it might provide an unresponsive experience for users. 
+
+In general, only use `CompileSynchronously = true` in the following situations:
+
+* If you have a long running job that only runs once. The performance of the compiled code might outweigh the downsides doing the compilation synchronously.
+* If you're profiling a Burst job and want to test the code from the Burst compiler. When you do this, perform a warmup to discard any timing measurements from the first call to the job. This is because the profiling data includes the compilation time and skews the result.
+* To aid with debugging the difference between managed and Burst compiled code. 

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation-warnings.md

@@ -0,0 +1,99 @@
+# Compilation warnings 
+
+This page describes common compilation warnings, and how to fix them.
+
+## IgnoreWarning attribute
+
+The [`Unity.Burst.CompilerServices.IgnoreWarningAttribute`](xref:Unity.Burst.CompilerServices.IgnoreWarningAttribute) attribute lets you suppress warnings for a specific function that is being compiled from Burst. However, the warnings that the Burst compiler generates are very important to pay attention to, so this attribute should be used sparingly and only when necessary. The sections below describe the specific situations in which you might want to suppress warnings.
+
+## BC1370
+
+Warning BC1370 produces the message:
+
+> An exception was thrown from a function without the correct `[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]` guard...
+
+This warning happens if Unity encounters a throw in code that `[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]` doesn't guard. In the Editor, thrown exceptions will be caught and logged to the Console, but in a Player build, a `throw` becomes an abort, which crashes your application. Burst warns you about these exceptions, and advises you to place them in functions guarded with `[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]`, because functions guarded with that attribute will not be included in Player builds. However, if you want to purposely throw an exception to crash your application, use the `IgnoreWarningAttribute` to suppress the warnings that Burst provides on the `throw`:
+
+```c#
+[IgnoreWarning(1370)]
+int DoSomethingMaybe(int x)
+{
+    if (x < 0) throw new Exception("Dang - sorry I crashed your game!");
+
+    return x * x;
+}
+```
+
+> [!NOTE]
+> This warning is only produced for exceptions that persist into Player builds. Editor-only or debug-only exception throws that aren't compiled into Player builds will not trigger this warning.
+
+## BC1371
+
+Warning BC1371 produces the message:
+
+> A call to the method 'xxx' has been discarded, due to its use as an argument to a discarded method...
+
+To understand this warning, consider the following example:
+
+```c#
+[BurstDiscard]
+static void DoSomeManagedStuff(int x)
+{
+    ///.. only run when Burst compilation is disabled
+}
+
+// A function that computes some result which we need to pass to managed code
+int BurstCompiledCode(int x,int y)
+{
+    return y+2*x;
+}
+
+[BurstCompile]
+void BurstMethod()
+{
+    var myValue = BurstCompiledCode(1,3);
+    DoSomeManagedStuff(myValue);
+}
+```
+
+When Unity compiles your C# code in release mode, it optimizes and removes the local variable `myValue`. This means that Burst receives something like the following code :
+
+```c#
+[BurstCompile]
+void BurstedMethod()
+{
+    DoSomeManagedStuff(BurstCompiledCode(1,3));
+}
+```
+
+This makes Burst generate the warning, because Burst discards `DoSomeManagedStuff`, along with the `BurstCompiledCode` argument. This means that the `BurstCompiledCode` function is no longer executed, which generates the warning.
+
+If this isn't what you intended then ensure the variable has multiple uses. For example: 
+
+```c#
+
+void IsUsed(ref int x)
+{
+    // Dummy function to prevent removal
+}
+
+[BurstCompile]
+void BurstedMethod()
+{
+    var myValue = BurstCompiledCode(1,3);
+    DoSomeManagedStuff(myValue);
+    IsUsed(ref myValue);
+}
+```
+
+Alternatively, if you're happy that the code is being discarded correctly, ignore the warning on the `BurstedMethod` like so: 
+
+```c#
+[IgnoreWarning(1371)]
+[BurstCompile]
+void BurstMethod()
+{
+    var myValue = BurstCompiledCode(1,3);
+    DoSomeManagedStuff(myValue);
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/compilation.md

@@ -0,0 +1,16 @@
+# Compilation
+
+Burst compiles your code in different ways, depending on its context. You can also change the way that the compiler behaves when compiling code.
+
+|**Topic**|**Description**|
+|---|---|
+|[Compilation overview](compilation-overview.md)| Understand the different compilation types.|
+[Synchronous compilation](compilation-synchronous.md)| Understand synchronous compilation.|
+|[BurstCompile attribute](compilation-burstcompile.md)|Customize the BurstCompile attribute to improve performance.|
+|[BurstDiscard attribute](compilation-burstdiscard.md)| Use the BurstDiscard attribute to select which portions of code to compile.|
+|[Generic jobs](compilation-generic-jobs.md)|Understand how Burst compiles jobs.|
+|[Compilation warnings](compilation-warnings.md)|Fix common compilation warnings.|
+
+## Additional resources
+
+* [C# language support](csharp-language-support.md)

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-burst-intrinsics-common.md

@@ -0,0 +1,25 @@
+# Burst Intrinsics Common class
+
+The [`Unity.Burst.Intrinsics.Common`](xref:Unity.Burst.Intrinsics.Common) intrinsics are for functionality shared across the hardware targets that Burst supports.
+
+## Pause
+
+[`Unity.Burst.Intrinsics.Common.Pause`](xref:Unity.Burst.Intrinsics.Common.Pause) is an intrinsic that requests that the CPU pause the current thread. It maps to `pause` on x86, and `yield` on ARM.
+
+Use it to stop spin locks over contending on an atomic access, which reduces contention and power on that section of code.
+
+## Prefetch
+
+The `Unity.Burst.Intrinsics.Common.Prefetch` is an experimental intrinsic that provides a hint that Burst should prefetch the memory location into the cache.
+
+Because the intrinsic is experimental, you must use the `UNITY_BURST_EXPERIMENTAL_PREFETCH_INTRINSIC` preprocessor define to get access to it.
+
+## umul128
+
+Use the [`Unity.Burst.Intrinsics.Common.umul128`](xref:Unity.Burst.Intrinsics.Common.umul128*) intrinsic to access 128-bit unsigned multiplication. These multiplies are useful for hashing functions. It maps 1:1 with hardware instructions on x86 and ARM targets.
+
+## InterlockedAnd & InterlockedOr
+
+The `Unity.Burst.Intrinsics.Common.InterlockedAnd` and `Unity.Burst.Intrinsics.Common.InterlockedOr` are experimental intrinsics that provides atomic and/or operations on `int`, `uint`, `long`, and `ulong` types.
+
+Because these intrinsics are experimental, you must use the `UNITY_BURST_EXPERIMENTAL_ATOMIC_INTRINSICS` preprocessor define to get access to them.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-burst-intrinsics-dllimport.md

@@ -0,0 +1,29 @@
+## DllImport and internal calls
+
+To call native functions, use [`[DllImport]`](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.dllimportattribute?view=net-6.0):
+
+```c#
+[DllImport("MyNativeLibrary")]
+public static extern int Foo(int arg);
+```
+
+Burst also supports internal calls implemented inside Unity:
+
+```c#
+// In UnityEngine.Mathf
+[MethodImpl(MethodImplOptions.InternalCall)]
+public static extern int ClosestPowerOfTwo(int value);
+```
+
+`DllImport` is only supported for [native plug-ins](https://docs.unity3d.com/Manual/NativePlugins.html), not platform-dependent libraries like `kernel32.dll`.
+
+For all `DllImport` and internal calls, you can only use the following types as parameter or return types:
+
+|**Type**|**Supported type**|
+|---|---|
+|Built-in and intrinsic types|`byte` / `sbyte`<br/>`short` / `ushort`<br/>`int` / `uint`<br/>`long` / `ulong`<br/>`float`<br/>`double`<br/>`System.IntPtr` / `System.UIntPtr`<br/>`Unity.Burst.Intrinsics.v64` / `Unity.Burst.Intrinsics.v128` / `Unity.Burst.Intrinsics.v256`|
+|Pointers and references|`sometype*` : Pointer to any of the other types in this list<br/>`ref sometype` : Reference to any of the other types in this list
+|Handle structs|`unsafe struct MyStruct { void* Ptr; }` : Struct containing a single pointer field<br/>`unsafe struct MyStruct { int Value; }` : Struct containing a single integer field
+
+> [!NOTE]
+>Passing structs by value isn't supported; you need to pass them through a pointer or reference. The only exception is that handle structs are supported. These are structs that contain a single field of pointer or integer type.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-burst-intrinsics-neon.md

@@ -0,0 +1,255 @@
+---
+uid: neon-intrinsics
+---
+
+# Burst Arm Neon intrinsics reference
+
+This page contains an ordered reference for the APIs in [Unity.Burst.Intrinsics.Arm.Neon](xref:Unity.Burst.Intrinsics.Arm.Neon). For information on how to use these, see the documentation on [Processor specific SIMD extensions](csharp-burst-intrinsics-processors.md).
+
+### Intrinsics type creation and conversion
+
+|Operation|Description|APIs|
+|---|---|---|
+|vcreate|Create vector|<details><summary>Click here to expand the API list</summary>[vcreate_f16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_f16*)<br/>[vcreate_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_f32*)<br/>[vcreate_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_f64*)<br/>[vcreate_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_s16*)<br/>[vcreate_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_s32*)<br/>[vcreate_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_s64*)<br/>[vcreate_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_s8*)<br/>[vcreate_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_u16*)<br/>[vcreate_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_u32*)<br/>[vcreate_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_u64*)<br/>[vcreate_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcreate_u8*)<br/></details>|
+|vdup_n|Duplicate (splat) value|<details><summary>Click here to expand the API list</summary>[vdup_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_f32*)<br/>[vdup_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_f64*)<br/>[vdup_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_s16*)<br/>[vdup_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_s32*)<br/>[vdup_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_s64*)<br/>[vdup_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_s8*)<br/>[vdup_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_u16*)<br/>[vdup_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_u32*)<br/>[vdup_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_u64*)<br/>[vdup_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_n_u8*)<br/>[vdupq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_f32*)<br/>[vdupq_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_f64*)<br/>[vdupq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_s16*)<br/>[vdupq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_s32*)<br/>[vdupq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_s64*)<br/>[vdupq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_s8*)<br/>[vdupq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_u16*)<br/>[vdupq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_u32*)<br/>[vdupq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_u64*)<br/>[vdupq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_n_u8*)<br/></details>|
+|vdup_lane|Duplicate (splat) vector element|<details><summary>Click here to expand the API list</summary>[vdup_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_f32*)<br/>[vdup_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_f64*)<br/>[vdup_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_s16*)<br/>[vdup_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_s32*)<br/>[vdup_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_s64*)<br/>[vdup_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_s8*)<br/>[vdup_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_u16*)<br/>[vdup_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_u32*)<br/>[vdup_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_u64*)<br/>[vdup_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_lane_u8*)<br/>[vdup_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_f32*)<br/>[vdup_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_f64*)<br/>[vdup_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_s16*)<br/>[vdup_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_s32*)<br/>[vdup_laneq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_s64*)<br/>[vdup_laneq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_s8*)<br/>[vdup_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_u16*)<br/>[vdup_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_u32*)<br/>[vdup_laneq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_u64*)<br/>[vdup_laneq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdup_laneq_u8*)<br/>[vdupq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_f32*)<br/>[vdupq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_f64*)<br/>[vdupq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_s16*)<br/>[vdupq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_s32*)<br/>[vdupq_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_s64*)<br/>[vdupq_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_s8*)<br/>[vdupq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_u16*)<br/>[vdupq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_u32*)<br/>[vdupq_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_u64*)<br/>[vdupq_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_lane_u8*)<br/>[vdupq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_f32*)<br/>[vdupq_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_f64*)<br/>[vdupq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_s16*)<br/>[vdupq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_s32*)<br/>[vdupq_laneq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_s64*)<br/>[vdupq_laneq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_s8*)<br/>[vdupq_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_u16*)<br/>[vdupq_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_u32*)<br/>[vdupq_laneq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_u64*)<br/>[vdupq_laneq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupq_laneq_u8*)<br/>[vdups_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdups_lane_f32*)<br/>[vdups_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdups_lane_s32*)<br/>[vdups_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdups_lane_u32*)<br/>[vdups_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdups_laneq_f32*)<br/>[vdups_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdups_laneq_s32*)<br/>[vdups_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdups_laneq_u32*)<br/>[vdupb_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupb_lane_s8*)<br/>[vdupb_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupb_lane_u8*)<br/>[vdupb_laneq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupb_laneq_s8*)<br/>[vdupb_laneq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupb_laneq_u8*)<br/>[vdupd_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupd_lane_f64*)<br/>[vdupd_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupd_lane_s64*)<br/>[vdupd_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupd_lane_u64*)<br/>[vdupd_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupd_laneq_f64*)<br/>[vdupd_laneq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupd_laneq_s64*)<br/>[vdupd_laneq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdupd_laneq_u64*)<br/>[vduph_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vduph_lane_s16*)<br/>[vduph_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vduph_lane_u16*)<br/>[vduph_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vduph_laneq_s16*)<br/>[vduph_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vduph_laneq_u16*)<br/></details>|
+|vmov_n|Duplicate (splat) value|<details><summary>Click here to expand the API list</summary>[vmov_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_f32*)<br/>[vmov_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_f64*)<br/>[vmov_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_s16*)<br/>[vmov_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_s32*)<br/>[vmov_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_s64*)<br/>[vmov_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_s8*)<br/>[vmov_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_u16*)<br/>[vmov_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_u32*)<br/>[vmov_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_u64*)<br/>[vmov_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmov_n_u8*)<br/>[vmovq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_f32*)<br/>[vmovq_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_f64*)<br/>[vmovq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_s16*)<br/>[vmovq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_s32*)<br/>[vmovq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_s64*)<br/>[vmovq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_s8*)<br/>[vmovq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_u16*)<br/>[vmovq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_u32*)<br/>[vmovq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_u64*)<br/>[vmovq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovq_n_u8*)<br/></details>|
+|vcopy_lane|Insert vector element from another vector element|<details><summary>Click here to expand the API list</summary>[vcopy_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_f32*)<br/>[vcopy_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_f64*)<br/>[vcopy_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_s16*)<br/>[vcopy_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_s32*)<br/>[vcopy_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_s64*)<br/>[vcopy_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_s8*)<br/>[vcopy_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_u16*)<br/>[vcopy_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_u32*)<br/>[vcopy_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_u64*)<br/>[vcopy_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_lane_u8*)<br/>[vcopy_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_f32*)<br/>[vcopy_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_f64*)<br/>[vcopy_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_s16*)<br/>[vcopy_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_s32*)<br/>[vcopy_laneq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_s64*)<br/>[vcopy_laneq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_s8*)<br/>[vcopy_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_u16*)<br/>[vcopy_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_u32*)<br/>[vcopy_laneq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_u64*)<br/>[vcopy_laneq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopy_laneq_u8*)<br/>[vcopyq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_f32*)<br/>[vcopyq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_f64*)<br/>[vcopyq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_s16*)<br/>[vcopyq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_s32*)<br/>[vcopyq_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_s64*)<br/>[vcopyq_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_s8*)<br/>[vcopyq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_u16*)<br/>[vcopyq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_u32*)<br/>[vcopyq_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_u64*)<br/>[vcopyq_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_lane_u8*)<br/>[vcopyq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_f32*)<br/>[vcopyq_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_f64*)<br/>[vcopyq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_s16*)<br/>[vcopyq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_s32*)<br/>[vcopyq_laneq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_s64*)<br/>[vcopyq_laneq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_s8*)<br/>[vcopyq_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_u16*)<br/>[vcopyq_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_u32*)<br/>[vcopyq_laneq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_u64*)<br/>[vcopyq_laneq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcopyq_laneq_u8*)<br/></details>|
+|vcombine|Join two vectors into a larger vector|<details><summary>Click here to expand the API list</summary>[vcombine_f16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_f16*)<br/>[vcombine_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_f32*)<br/>[vcombine_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_f64*)<br/>[vcombine_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_s16*)<br/>[vcombine_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_s32*)<br/>[vcombine_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_s64*)<br/>[vcombine_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_s8*)<br/>[vcombine_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_u16*)<br/>[vcombine_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_u32*)<br/>[vcombine_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_u64*)<br/>[vcombine_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcombine_u8*)<br/></details>|
+|vget_high|Get the higher half of the vector|<details><summary>Click here to expand the API list</summary>[vget_high_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_f32*)<br/>[vget_high_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_f64*)<br/>[vget_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_s16*)<br/>[vget_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_s32*)<br/>[vget_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_s64*)<br/>[vget_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_s8*)<br/>[vget_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_u16*)<br/>[vget_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_u32*)<br/>[vget_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_u64*)<br/>[vget_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_high_u8*)<br/></details>|
+|vget_low|Get the lower half of the vector|<details><summary>Click here to expand the API list</summary>[vget_low_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_f32*)<br/>[vget_low_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_f64*)<br/>[vget_low_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_s16*)<br/>[vget_low_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_s32*)<br/>[vget_low_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_s64*)<br/>[vget_low_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_s8*)<br/>[vget_low_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_u16*)<br/>[vget_low_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_u32*)<br/>[vget_low_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_u64*)<br/>[vget_low_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_low_u8*)<br/></details>|
+
+### Arithmetic
+
+|Operation|Description|APIs|
+|---|---|---|
+|vadd|Add|<details><summary>Click here to expand the API list</summary>[vadd_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_f32*)<br/>[vadd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_f64*)<br/>[vadd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_s16*)<br/>[vadd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_s32*)<br/>[vadd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_s64*)<br/>[vadd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_s8*)<br/>[vadd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_u16*)<br/>[vadd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_u32*)<br/>[vadd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_u64*)<br/>[vadd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vadd_u8*)<br/>[vaddq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_f32*)<br/>[vaddq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_f64*)<br/>[vaddq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_s16*)<br/>[vaddq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_s32*)<br/>[vaddq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_s64*)<br/>[vaddq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_s8*)<br/>[vaddq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_u16*)<br/>[vaddq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_u32*)<br/>[vaddq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_u64*)<br/>[vaddq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddq_u8*)<br/>[vaddd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddd_s64*)<br/>[vaddd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddd_u64*)<br/></details>|
+|vaddv|Add across vector|<details><summary>Click here to expand the API list</summary>[vaddv_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_f32*)<br/>[vaddv_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_s16*)<br/>[vaddv_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_s32*)<br/>[vaddv_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_s8*)<br/>[vaddv_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_u16*)<br/>[vaddv_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_u32*)<br/>[vaddv_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddv_u8*)<br/>[vaddvq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_f32*)<br/>[vaddvq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_f64*)<br/>[vaddvq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_s16*)<br/>[vaddvq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_s32*)<br/>[vaddvq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_s64*)<br/>[vaddvq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_s8*)<br/>[vaddvq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_u16*)<br/>[vaddvq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_u32*)<br/>[vaddvq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_u64*)<br/>[vaddvq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddvq_u8*)<br/></details>|
+|vaddl|Add long|<details><summary>Click here to expand the API list</summary>[vaddl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_s16*)<br/>[vaddl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_s32*)<br/>[vaddl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_s8*)<br/>[vaddl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_u16*)<br/>[vaddl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_u32*)<br/>[vaddl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_u8*)<br/>[vaddl_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_high_s16*)<br/>[vaddl_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_high_s32*)<br/>[vaddl_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_high_s8*)<br/>[vaddl_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_high_u16*)<br/>[vaddl_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_high_u32*)<br/>[vaddl_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddl_high_u8*)<br/></details>|
+|vaddlv|Add long across Vector|<details><summary>Click here to expand the API list</summary>[vaddlv_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlv_s16*)<br/>[vaddlv_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlv_s32*)<br/>[vaddlv_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlv_s8*)<br/>[vaddlv_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlv_u16*)<br/>[vaddlv_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlv_u32*)<br/>[vaddlv_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlv_u8*)<br/>[vaddlvq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlvq_s16*)<br/>[vaddlvq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlvq_s32*)<br/>[vaddlvq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlvq_s8*)<br/>[vaddlvq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlvq_u16*)<br/>[vaddlvq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlvq_u32*)<br/>[vaddlvq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddlvq_u8*)<br/></details>|
+|vaddw|Add wide|<details><summary>Click here to expand the API list</summary>[vaddw_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_s16*)<br/>[vaddw_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_s32*)<br/>[vaddw_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_s8*)<br/>[vaddw_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_u16*)<br/>[vaddw_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_u32*)<br/>[vaddw_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_u8*)<br/>[vaddw_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_high_s16*)<br/>[vaddw_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_high_s32*)<br/>[vaddw_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_high_s8*)<br/>[vaddw_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_high_u16*)<br/>[vaddw_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_high_u32*)<br/>[vaddw_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddw_high_u8*)<br/></details>|
+|vhadd|Halving add|<details><summary>Click here to expand the API list</summary>[vhadd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhadd_s16*)<br/>[vhadd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhadd_s32*)<br/>[vhadd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhadd_s8*)<br/>[vhadd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhadd_u16*)<br/>[vhadd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhadd_u32*)<br/>[vhadd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhadd_u8*)<br/>[vhaddq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhaddq_s16*)<br/>[vhaddq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhaddq_s32*)<br/>[vhaddq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhaddq_s8*)<br/>[vhaddq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhaddq_u16*)<br/>[vhaddq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhaddq_u32*)<br/>[vhaddq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhaddq_u8*)<br/></details>|
+|vrhadd|Rounding halving add|<details><summary>Click here to expand the API list</summary>[vrhadd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhadd_s16*)<br/>[vrhadd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhadd_s32*)<br/>[vrhadd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhadd_s8*)<br/>[vrhadd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhadd_u16*)<br/>[vrhadd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhadd_u32*)<br/>[vrhadd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhadd_u8*)<br/>[vrhaddq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhaddq_s16*)<br/>[vrhaddq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhaddq_s32*)<br/>[vrhaddq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhaddq_s8*)<br/>[vrhaddq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhaddq_u16*)<br/>[vrhaddq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhaddq_u32*)<br/>[vrhaddq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrhaddq_u8*)<br/></details>|
+|vqadd|Saturating add|<details><summary>Click here to expand the API list</summary>[vqadd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_s16*)<br/>[vqadd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_s32*)<br/>[vqadd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_s64*)<br/>[vqadd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_s8*)<br/>[vqadd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_u16*)<br/>[vqadd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_u32*)<br/>[vqadd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_u64*)<br/>[vqadd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadd_u8*)<br/>[vqaddq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_s16*)<br/>[vqaddq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_s32*)<br/>[vqaddq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_s64*)<br/>[vqaddq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_s8*)<br/>[vqaddq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_u16*)<br/>[vqaddq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_u32*)<br/>[vqaddq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_u64*)<br/>[vqaddq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddq_u8*)<br/>[vqaddb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddb_s8*)<br/>[vqaddb_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddb_u8*)<br/>[vqaddh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddh_s16*)<br/>[vqaddh_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddh_u16*)<br/>[vqadds_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadds_s32*)<br/>[vqadds_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqadds_u32*)<br/>[vqaddd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddd_s64*)<br/>[vqaddd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqaddd_u64*)<br/></details>|
+|vsqadd|Unsigned saturating Accumulate of signed value|<details><summary>Click here to expand the API list</summary>[vsqadd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqadd_u16*)<br/> [vsqadd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqadd_u32*)<br/> [vsqadd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqadd_u64*)<br/> [vsqadd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqadd_u8*)<br/> [vsqaddq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddq_u16*)<br/> [vsqaddq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddq_u32*)<br/> [vsqaddq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddq_u64*)<br/> [vsqaddq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddq_u8*)<br/> [vsqaddb_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddb_u8*)<br/> [vsqaddh_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddh_u16*)<br/> [vsqadds_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqadds_u32*)<br/> [vsqaddd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqaddd_u64*)<br/></details>|
+|vuqadd|Signed saturating Accumulate of unsigned value|<details><summary>Click here to expand the API list</summary>[vuqadd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqadd_s16*)<br/> [vuqadd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqadd_s32*)<br/> [vuqadd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqadd_s64*)<br/> [vuqadd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqadd_s8*)<br/> [vuqaddq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddq_s16*)<br/> [vuqaddq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddq_s32*)<br/> [vuqaddq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddq_s64*)<br/> [vuqaddq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddq_s8*)<br/> [vuqaddb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddb_s8*)<br/> [vuqaddh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddh_s16*)<br/> [vuqadds_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqadds_s32*)<br/> [vuqaddd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuqaddd_s64*)<br/></details>|
+|vaddhn|Add returning high narrow|<details><summary>Click here to expand the API list</summary>[vaddhn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_s16*)<br/>[vaddhn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_s32*)<br/>[vaddhn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_s64*)<br/>[vaddhn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_u16*)<br/>[vaddhn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_u32*)<br/>[vaddhn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_u64*)<br/>[vaddhn_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_high_s16*)<br/>[vaddhn_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_high_s32*)<br/>[vaddhn_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_high_s64*)<br/>[vaddhn_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_high_u16*)<br/>[vaddhn_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_high_u32*)<br/>[vaddhn_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vaddhn_high_u64*)<br/></details>|
+|vraddhn|Rounding add returning high narrow|<details><summary>Click here to expand the API list</summary>[vraddhn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_s16*)<br/>[vraddhn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_s32*)<br/>[vraddhn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_s64*)<br/>[vraddhn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_u16*)<br/>[vraddhn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_u32*)<br/>[vraddhn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_u64*)<br/>[vraddhn_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_high_s16*)<br/>[vraddhn_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_high_s32*)<br/>[vraddhn_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_high_s64*)<br/>[vraddhn_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_high_u16*)<br/>[vraddhn_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_high_u32*)<br/>[vraddhn_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vraddhn_high_u64*)<br/></details>|
+|vpadd|Add pairwise (vector)|<details><summary>Click here to expand the API list</summary>[vpadd_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_f32*)<br/>[vpadd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_s16*)<br/>[vpadd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_s32*)<br/>[vpadd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_s8*)<br/>[vpadd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_u16*)<br/>[vpadd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_u32*)<br/>[vpadd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadd_u8*)<br/>[vpaddq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_f32*)<br/>[vpaddq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_f64*)<br/>[vpaddq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_s16*)<br/>[vpaddq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_s32*)<br/>[vpaddq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_s64*)<br/>[vpaddq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_s8*)<br/>[vpaddq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_u16*)<br/>[vpaddq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_u32*)<br/>[vpaddq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_u64*)<br/>[vpaddq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddq_u8*)<br/>[vpadds_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadds_f32*)<br/>[vpaddd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddd_f64*)<br/>[vpaddd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddd_s64*)<br/>[vpaddd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddd_u64*)<br/></details>|
+|vpaddl|Signed add long pairwise|<details><summary>Click here to expand the API list</summary>[vpaddl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddl_s16*)<br/>[vpaddl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddl_s32*)<br/>[vpaddl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddl_s8*)<br/>[vpaddl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddl_u16*)<br/>[vpaddl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddl_u32*)<br/>[vpaddl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddl_u8*)<br/>[vpaddlq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddlq_s16*)<br/>[vpaddlq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddlq_s32*)<br/>[vpaddlq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddlq_s8*)<br/>[vpaddlq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddlq_u16*)<br/>[vpaddlq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddlq_u32*)<br/>[vpaddlq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpaddlq_u8*)<br/></details>|
+|vpadal|Signed add and accumulate long pairwise|<details><summary>Click here to expand the API list</summary>[vpadal_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadal_s16*)<br/>[vpadal_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadal_s32*)<br/>[vpadal_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadal_s8*)<br/>[vpadal_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadal_u16*)<br/>[vpadal_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadal_u32*)<br/>[vpadal_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadal_u8*)<br/>[vpadalq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadalq_s16*)<br/>[vpadalq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadalq_s32*)<br/>[vpadalq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadalq_s8*)<br/>[vpadalq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadalq_u16*)<br/>[vpadalq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadalq_u32*)<br/>[vpadalq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpadalq_u8*)<br/></details>|
+|vsub|Subtract|<details><summary>Click here to expand the API list</summary>[vsub_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_f32*)<br/>[vsub_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_f64*)<br/>[vsub_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_s16*)<br/>[vsub_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_s32*)<br/>[vsub_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_s64*)<br/>[vsub_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_s8*)<br/>[vsub_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_u16*)<br/>[vsub_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_u32*)<br/>[vsub_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_u64*)<br/>[vsub_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsub_u8*)<br/>[vsubq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_f32*)<br/>[vsubq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_f64*)<br/>[vsubq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_s16*)<br/>[vsubq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_s32*)<br/>[vsubq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_s64*)<br/>[vsubq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_s8*)<br/>[vsubq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_u16*)<br/>[vsubq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_u32*)<br/>[vsubq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_u64*)<br/>[vsubq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubq_u8*)<br/>[vsubd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubd_s64*)<br/>[vsubd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubd_u64*)<br/></details>|
+|vsubl|Subtract long|<details><summary>Click here to expand the API list</summary>[vsubl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_s16*)<br/>[vsubl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_s32*)<br/>[vsubl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_s8*)<br/>[vsubl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_u16*)<br/>[vsubl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_u32*)<br/>[vsubl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_u8*)<br/>[vsubl_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_high_s16*)<br/>[vsubl_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_high_s32*)<br/>[vsubl_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_high_s8*)<br/>[vsubl_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_high_u16*)<br/>[vsubl_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_high_u32*)<br/>[vsubl_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubl_high_u8*)<br/></details>|
+|vsubw|Subtract wide|<details><summary>Click here to expand the API list</summary>[vsubw_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_s16*)<br/>[vsubw_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_s32*)<br/>[vsubw_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_s8*)<br/>[vsubw_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_u16*)<br/>[vsubw_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_u32*)<br/>[vsubw_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_u8*)<br/>[vsubw_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_high_s16*)<br/>[vsubw_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_high_s32*)<br/>[vsubw_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_high_s8*)<br/>[vsubw_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_high_u16*)<br/>[vsubw_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_high_u32*)<br/>[vsubw_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubw_high_u8*)<br/></details>|
+|vhsub|Halving subtract|<details><summary>Click here to expand the API list</summary>[vhsub_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsub_s16*)<br/>[vhsub_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsub_s32*)<br/>[vhsub_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsub_s8*)<br/>[vhsub_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsub_u16*)<br/>[vhsub_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsub_u32*)<br/>[vhsub_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsub_u8*)<br/>[vhsubq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsubq_s16*)<br/>[vhsubq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsubq_s32*)<br/>[vhsubq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsubq_s8*)<br/>[vhsubq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsubq_u16*)<br/>[vhsubq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsubq_u32*)<br/>[vhsubq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vhsubq_u8*)<br/></details>|
+|vqsub|Saturating subtract|<details><summary>Click here to expand the API list</summary>[vqsub_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_s16*)<br/> [vqsub_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_s32*)<br/> [vqsub_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_s64*)<br/> [vqsub_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_s8*)<br/> [vqsub_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_u16*)<br/> [vqsub_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_u32*)<br/> [vqsub_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_u64*)<br/> [vqsub_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsub_u8*)<br/> [vqsubq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_s16*)<br/> [vqsubq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_s32*)<br/> [vqsubq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_s64*)<br/> [vqsubq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_s8*)<br/> [vqsubq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_u16*)<br/> [vqsubq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_u32*)<br/> [vqsubq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_u64*)<br/> [vqsubq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubq_u8*)<br/> [vqsubb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubb_s8*)<br/> [vqsubb_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubb_u8*)<br/> [vqsubh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubh_s16*)<br/> [vqsubh_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubh_u16*)<br/> [vqsubs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubs_s32*)<br/> [vqsubs_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubs_u32*)<br/> [vqsubd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubd_s64*)<br/> [vqsubd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqsubd_u64*)<br/></details>|
+|vsubhn|Subtract returning high narrow|<details><summary>Click here to expand the API list</summary>[vsubhn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_s16*)<br/>[vsubhn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_s32*)<br/>[vsubhn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_s64*)<br/>[vsubhn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_u16*)<br/>[vsubhn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_u32*)<br/>[vsubhn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_u64*)<br/>[vsubhn_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_high_s16*)<br/>[vsubhn_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_high_s32*)<br/>[vsubhn_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_high_s64*)<br/>[vsubhn_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_high_u16*)<br/>[vsubhn_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_high_u32*)<br/>[vsubhn_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsubhn_high_u64*)<br/></details>|
+|vrsubhn|Rounding subtract returning high narrow|<details><summary>Click here to expand the API list</summary>[vrsubhn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_s16*)<br/>[vrsubhn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_s32*)<br/>[vrsubhn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_s64*)<br/>[vrsubhn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_u16*)<br/>[vrsubhn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_u32*)<br/>[vrsubhn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_u64*)<br/>[vrsubhn_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_high_s16*)<br/>[vrsubhn_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_high_s32*)<br/>[vrsubhn_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_high_s64*)<br/>[vrsubhn_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_high_u16*)<br/>[vrsubhn_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_high_u32*)<br/>[vrsubhn_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsubhn_high_u64*)<br/></details>|
+
+### Multiply
+
+|Operation|Description|APIs|
+|---|---|---|
+|vmul|Multiply (vector)|<details><summary>Click here to expand the API list</summary>[vmul_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_f32*)<br/>[vmul_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_f64*)<br/>[vmul_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_s16*)<br/>[vmul_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_s32*)<br/>[vmul_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_s8*)<br/>[vmul_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_u16*)<br/>[vmul_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_u32*)<br/>[vmul_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_u8*)<br/>[vmulq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_f32*)<br/>[vmulq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_f64*)<br/>[vmulq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_s16*)<br/>[vmulq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_s32*)<br/>[vmulq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_s8*)<br/>[vmulq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_u16*)<br/>[vmulq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_u32*)<br/>[vmulq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_u8*)<br/></details>|
+|vmul_n|Vector multiply by scalar|<details><summary>Click here to expand the API list</summary>[vmul_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_n_f32*)<br/>[vmul_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_n_f64*)<br/>[vmul_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_n_s16*)<br/>[vmul_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_n_s32*)<br/>[vmul_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_n_u16*)<br/>[vmul_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_n_u32*)<br/>[vmulq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_n_f32*)<br/>[vmulq_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_n_f64*)<br/>[vmulq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_n_s16*)<br/>[vmulq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_n_s32*)<br/>[vmulq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_n_u16*)<br/>[vmulq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_n_u32*)<br/></details>|
+|vmul_lane|Multiply (vector)|<details><summary>Click here to expand the API list</summary>[vmul_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_lane_f32*)<br/>[vmul_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_lane_f64*)<br/>[vmul_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_lane_s16*)<br/>[vmul_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_lane_s32*)<br/>[vmul_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_lane_u16*)<br/>[vmul_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_lane_u32*)<br/>[vmul_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_laneq_f32*)<br/>[vmul_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_laneq_f64*)<br/>[vmul_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_laneq_s16*)<br/>[vmul_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_laneq_s32*)<br/>[vmul_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_laneq_u16*)<br/>[vmul_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmul_laneq_u32*)<br/>[vmulq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_lane_f32*)<br/>[vmulq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_lane_f64*)<br/>[vmulq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_lane_s16*)<br/>[vmulq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_lane_s32*)<br/>[vmulq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_lane_u16*)<br/>[vmulq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_lane_u32*)<br/>[vmulq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_laneq_f32*)<br/>[vmulq_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_laneq_f64*)<br/>[vmulq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_laneq_s16*)<br/>[vmulq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_laneq_s32*)<br/>[vmulq_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_laneq_u16*)<br/>[vmulq_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulq_laneq_u32*)<br/>[vmuls_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmuls_lane_f32*)<br/>[vmuls_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmuls_laneq_f32*)<br/>[vmuld_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmuld_lane_f64*)<br/>[vmuld_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmuld_laneq_f64*)<br/></details>|
+|vmull|Multiply long (vector)|<details><summary>Click here to expand the API list</summary>[vmull_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_s16*)<br/>[vmull_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_s32*)<br/>[vmull_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_s8*)<br/>[vmull_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_u16*)<br/>[vmull_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_u32*)<br/>[vmull_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_u8*)<br/>[vmull_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_s16*)<br/>[vmull_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_s32*)<br/>[vmull_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_s8*)<br/>[vmull_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_u16*)<br/>[vmull_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_u32*)<br/>[vmull_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_u8*)<br/></details>|
+|vmull_n|Vector long multiply by scalar|<details><summary>Click here to expand the API list</summary>[vmull_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_n_s16*)<br/>[vmull_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_n_s32*)<br/>[vmull_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_n_u16*)<br/>[vmull_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_n_u32*)<br/>[vmull_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_n_s16*)<br/>[vmull_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_n_s32*)<br/>[vmull_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_n_u16*)<br/>[vmull_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_n_u32*)<br/></details>|
+|vmull_lane|Multiply long (vector)|<details><summary>Click here to expand the API list</summary>[vmull_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_lane_s16*)<br/>[vmull_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_lane_s32*)<br/>[vmull_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_lane_u16*)<br/>[vmull_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_lane_u32*)<br/>[vmull_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_laneq_s16*)<br/>[vmull_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_laneq_s32*)<br/>[vmull_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_laneq_u16*)<br/>[vmull_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_laneq_u32*)<br/>[vmull_high_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_lane_s16*)<br/>[vmull_high_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_lane_s32*)<br/>[vmull_high_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_lane_u16*)<br/>[vmull_high_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_lane_u32*)<br/>[vmull_high_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_laneq_s16*)<br/>[vmull_high_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_laneq_s32*)<br/>[vmull_high_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_laneq_u16*)<br/>[vmull_high_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmull_high_laneq_u32*)<br/></details>|
+|vmulx|Floating-point multiply extended|<details><summary>Click here to expand the API list</summary>[vmulx_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulx_f32*)<br/>[vmulx_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulx_f64*)<br/>[vmulx_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulx_lane_f32*)<br/>[vmulx_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulx_lane_f64*)<br/>[vmulx_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulx_laneq_f32*)<br/>[vmulx_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulx_laneq_f64*)<br/>[vmulxq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxq_f32*)<br/>[vmulxq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxq_f64*)<br/>[vmulxq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxq_lane_f32*)<br/>[vmulxq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxq_lane_f64*)<br/>[vmulxq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxq_laneq_f32*)<br/>[vmulxq_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxq_laneq_f64*)<br/>[vmulxs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxs_f32*)<br/>[vmulxs_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxs_lane_f32*)<br/>[vmulxs_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxs_laneq_f32*)<br/>[vmulxd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxd_f64*)<br/>[vmulxd_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxd_lane_f64*)<br/>[vmulxd_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmulxd_laneq_f64*)<br/></details>|
+|vmla|Multiply-add to accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vmla_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_f32*)<br/>[vmla_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_f64*)<br/>[vmla_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_s16*)<br/>[vmla_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_s32*)<br/>[vmla_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_s8*)<br/>[vmla_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_u16*)<br/>[vmla_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_u32*)<br/>[vmla_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_u8*)<br/>[vmlaq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_f32*)<br/>[vmlaq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_f64*)<br/>[vmlaq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_s16*)<br/>[vmlaq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_s32*)<br/>[vmlaq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_s8*)<br/>[vmlaq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_u16*)<br/>[vmlaq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_u32*)<br/>[vmlaq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_u8*)<br/></details>|
+|vmla_lane|Vector multiply accumulate with scalar|<details><summary>Click here to expand the API list</summary>[vmla_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_lane_f32*)<br/>[vmla_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_lane_s16*)<br/>[vmla_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_lane_s32*)<br/>[vmla_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_lane_u16*)<br/>[vmla_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_lane_u32*)<br/>[vmla_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_laneq_f32*)<br/>[vmla_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_laneq_s16*)<br/>[vmla_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_laneq_s32*)<br/>[vmla_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_laneq_u16*)<br/>[vmla_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_laneq_u32*)<br/>[vmlaq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_lane_f32*)<br/>[vmlaq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_lane_s16*)<br/>[vmlaq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_lane_s32*)<br/>[vmlaq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_lane_u16*)<br/>[vmlaq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_lane_u32*)<br/>[vmlaq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_laneq_f32*)<br/>[vmlaq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_laneq_s16*)<br/>[vmlaq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_laneq_s32*)<br/>[vmlaq_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_laneq_u16*)<br/>[vmlaq_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_laneq_u32*)<br/></details>|
+|vmla_n|Vector multiply accumulate with scalar|<details><summary>Click here to expand the API list</summary>[vmla_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_n_f32*)<br/>[vmla_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_n_s16*)<br/>[vmla_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_n_s32*)<br/>[vmla_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_n_u16*)<br/>[vmla_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmla_n_u32*)<br/>[vmlaq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_n_f32*)<br/>[vmlaq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_n_s16*)<br/>[vmlaq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_n_s32*)<br/>[vmlaq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_n_u16*)<br/>[vmlaq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlaq_n_u32*)<br/></details>|
+|vmlal|Multiply-accumulate long (vector)|<details><summary>Click here to expand the API list</summary>[vmlal_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_s16*)<br/>[vmlal_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_s32*)<br/>[vmlal_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_s8*)<br/>[vmlal_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_u16*)<br/>[vmlal_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_u32*)<br/>[vmlal_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_u8*)<br/>[vmlal_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_s16*)<br/>[vmlal_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_s32*)<br/>[vmlal_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_s8*)<br/>[vmlal_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_u16*)<br/>[vmlal_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_u32*)<br/>[vmlal_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_u8*)<br/></details>|
+|vmlal_lane|Multiply-accumulate long with scalar|<details><summary>Click here to expand the API list</summary>[vmlal_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_lane_s16*)<br/>[vmlal_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_lane_s32*)<br/>[vmlal_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_lane_u16*)<br/>[vmlal_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_lane_u32*)<br/>[vmlal_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_laneq_s16*)<br/>[vmlal_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_laneq_s32*)<br/>[vmlal_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_laneq_u16*)<br/>[vmlal_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_laneq_u32*)<br/>[vmlal_high_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_lane_s16*)<br/>[vmlal_high_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_lane_s32*)<br/>[vmlal_high_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_lane_u16*)<br/>[vmlal_high_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_lane_u32*)<br/>[vmlal_high_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_laneq_s16*)<br/>[vmlal_high_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_laneq_s32*)<br/>[vmlal_high_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_laneq_u16*)<br/>[vmlal_high_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_laneq_u32*)<br/></details>|
+|vmlal_n|Multiply-accumulate long with scalar|<details><summary>Click here to expand the API list</summary>[vmlal_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_n_s16*)<br/>[vmlal_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_n_s32*)<br/>[vmlal_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_n_u16*)<br/>[vmlal_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_n_u32*)<br/>[vmlal_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_n_s16*)<br/>[vmlal_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_n_s32*)<br/>[vmlal_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_n_u16*)<br/>[vmlal_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlal_high_n_u32*)<br/></details>|
+|vmls|Multiply-subtract from accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vmls_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_f32*)<br/>[vmls_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_f64*)<br/>[vmls_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_s16*)<br/>[vmls_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_s32*)<br/>[vmls_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_s8*)<br/>[vmls_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_u16*)<br/>[vmls_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_u32*)<br/>[vmls_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_u8*)<br/>[vmlsq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_f32*)<br/>[vmlsq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_f64*)<br/>[vmlsq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_s16*)<br/>[vmlsq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_s32*)<br/>[vmlsq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_s8*)<br/>[vmlsq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_u16*)<br/>[vmlsq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_u32*)<br/>[vmlsq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_u8*)<br/></details>|
+|vmls_lane|Vector multiply subtract with scalar|<details><summary>Click here to expand the API list</summary>[vmls_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_lane_f32*)<br/>[vmls_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_lane_s16*)<br/>[vmls_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_lane_s32*)<br/>[vmls_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_lane_u16*)<br/>[vmls_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_lane_u32*)<br/>[vmls_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_laneq_f32*)<br/>[vmls_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_laneq_s16*)<br/>[vmls_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_laneq_s32*)<br/>[vmls_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_laneq_u16*)<br/>[vmls_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_laneq_u32*)<br/>[vmlsq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_lane_f32*)<br/>[vmlsq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_lane_s16*)<br/>[vmlsq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_lane_s32*)<br/>[vmlsq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_lane_u16*)<br/>[vmlsq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_lane_u32*)<br/>[vmlsq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_laneq_f32*)<br/>[vmlsq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_laneq_s16*)<br/>[vmlsq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_laneq_s32*)<br/>[vmlsq_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_laneq_u16*)<br/>[vmlsq_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_laneq_u32*)<br/></details>|
+|vmls_n|Vector multiply subtract with scalar|<details><summary>Click here to expand the API list</summary>[vmls_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_n_f32*)<br/>[vmls_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_n_s16*)<br/>[vmls_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_n_s32*)<br/>[vmls_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_n_u16*)<br/>[vmls_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmls_n_u32*)<br/>[vmlsq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_n_f32*)<br/>[vmlsq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_n_s16*)<br/>[vmlsq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_n_s32*)<br/>[vmlsq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_n_u16*)<br/>[vmlsq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsq_n_u32*)<br/></details>|
+|vmlsl|Multiply-subtract long (vector)|<details><summary>Click here to expand the API list</summary>[vmlsl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_s16*)<br/>[vmlsl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_s32*)<br/>[vmlsl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_s8*)<br/>[vmlsl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_u16*)<br/>[vmlsl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_u32*)<br/>[vmlsl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_u8*)<br/>[vmlsl_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_s16*)<br/>[vmlsl_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_s32*)<br/>[vmlsl_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_s8*)<br/>[vmlsl_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_u16*)<br/>[vmlsl_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_u32*)<br/>[vmlsl_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_u8*)<br/></details>|
+|vmlsl_lane|Vector multiply-subtract long with scalar|<details><summary>Click here to expand the API list</summary>[vmlsl_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_lane_s16*)<br/>[vmlsl_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_lane_s32*)<br/>[vmlsl_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_lane_u16*)<br/>[vmlsl_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_lane_u32*)<br/>[vmlsl_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_laneq_s16*)<br/>[vmlsl_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_laneq_s32*)<br/>[vmlsl_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_laneq_u16*)<br/>[vmlsl_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_laneq_u32*)<br/>[vmlsl_high_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_lane_s16*)<br/>[vmlsl_high_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_lane_s32*)<br/>[vmlsl_high_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_lane_u16*)<br/>[vmlsl_high_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_lane_u32*)<br/>[vmlsl_high_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_laneq_s16*)<br/>[vmlsl_high_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_laneq_s32*)<br/>[vmlsl_high_laneq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_laneq_u16*)<br/>[vmlsl_high_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_laneq_u32*)<br/></details>|
+|vmlsl_n|Vector multiply-subtract long with scalar|<details><summary>Click here to expand the API list</summary>[vmlsl_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_n_s16*)<br/>[vmlsl_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_n_s32*)<br/>[vmlsl_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_n_u16*)<br/>[vmlsl_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_n_u32*)<br/>[vmlsl_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_n_s16*)<br/>[vmlsl_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_n_s32*)<br/>[vmlsl_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_n_u16*)<br/>[vmlsl_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmlsl_high_n_u32*)<br/></details>|
+|vqdmull|Signed saturating doubling multiply long|<details><summary>Click here to expand the API list</summary>[vqdmull_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_s16*)<br/>[vqdmull_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_s32*)<br/>[vqdmullh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmullh_s16*)<br/>[vqdmulls_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulls_s32*)<br/>[vqdmull_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_s16*)<br/>[vqdmull_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_s32*)<br/></details>|
+|vqdmull_lane|Vector saturating doubling multiply long with scalar|<details><summary>Click here to expand the API list</summary>[vqdmull_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_lane_s16*)<br/>[vqdmull_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_lane_s32*)<br/>[vqdmull_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_laneq_s16*)<br/>[vqdmull_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_laneq_s32*)<br/>[vqdmullh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmullh_lane_s16*)<br/>[vqdmullh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmullh_laneq_s16*)<br/>[vqdmulls_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulls_lane_s32*)<br/>[vqdmulls_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulls_laneq_s32*)<br/>[vqdmull_high_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_lane_s16*)<br/>[vqdmull_high_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_lane_s32*)<br/>[vqdmull_high_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_laneq_s16*)<br/>[vqdmull_high_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_laneq_s32*)<br/></details>|
+|vqdmull_n|Vector saturating doubling multiply long with scalar|<details><summary>Click here to expand the API list</summary>[vqdmull_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_n_s16*)<br/>[vqdmull_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_n_s32*)<br/>[vqdmull_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_n_s16*)<br/>[vqdmull_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmull_high_n_s32*)<br/></details>|
+|vqdmulh|Saturating doubling multiply returning high half|<details><summary>Click here to expand the API list</summary>[vqdmulh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_s16*)<br/>[vqdmulh_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_s32*)<br/>[vqdmulhq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_s16*)<br/>[vqdmulhq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_s32*)<br/>[vqdmulhh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhh_s16*)<br/>[vqdmulhs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhs_s32*)<br/></details>|
+|vqdmulh_lane|Vector saturating doubling multiply high by scalar|<details><summary>Click here to expand the API list</summary>[vqdmulh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_lane_s16*)<br/>[vqdmulh_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_lane_s32*)<br/>[vqdmulh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_laneq_s16*)<br/>[vqdmulh_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_laneq_s32*)<br/>[vqdmulhq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_lane_s16*)<br/>[vqdmulhq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_lane_s32*)<br/>[vqdmulhq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_laneq_s16*)<br/>[vqdmulhq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_laneq_s32*)<br/>[vqdmulhh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhh_lane_s16*)<br/>[vqdmulhh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhh_laneq_s16*)<br/>[vqdmulhs_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhs_lane_s32*)<br/>[vqdmulhs_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhs_laneq_s32*)<br/></details>|
+|vqdmulh_n|Vector saturating doubling multiply high by scalar|<details><summary>Click here to expand the API list</summary>[vqdmulh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_n_s16*)<br/>[vqdmulh_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulh_n_s32*)<br/>[vqdmulhq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_n_s16*)<br/>[vqdmulhq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmulhq_n_s32*)<br/></details>|
+|vqrdmulh|Saturating rounding doubling multiply returning high half|<details><summary>Click here to expand the API list</summary>[vqrdmulh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_s16*)<br/>[vqrdmulh_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_s32*)<br/>[vqrdmulhq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_s16*)<br/>[vqrdmulhq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_s32*)<br/>[vqrdmulhh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhh_s16*)<br/>[vqrdmulhs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhs_s32*)<br/></details>|
+|vqrdmulh_lane|Vector saturating rounding doubling multiply high with scalar|<details><summary>Click here to expand the API list</summary>[vqrdmulh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_lane_s16*)<br/>[vqrdmulh_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_lane_s32*)<br/>[vqrdmulh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_laneq_s16*)<br/>[vqrdmulh_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_laneq_s32*)<br/>[vqrdmulhq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_lane_s16*)<br/>[vqrdmulhq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_lane_s32*)<br/>[vqrdmulhq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_laneq_s16*)<br/>[vqrdmulhq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_laneq_s32*)<br/>[vqrdmulhh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhh_lane_s16*)<br/>[vqrdmulhh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhh_laneq_s16*)<br/>[vqrdmulhs_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhs_lane_s32*)<br/>[vqrdmulhs_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhs_laneq_s32*)<br/></details>|
+|vqrdmulh_n|Vector saturating rounding doubling multiply high with scalar|<details><summary>Click here to expand the API list</summary>[vqrdmulh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_n_s16*)<br/>[vqrdmulh_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulh_n_s32*)<br/>[vqrdmulhq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_n_s16*)<br/>[vqrdmulhq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmulhq_n_s32*)<br/></details>|
+|vqdmlal|Saturating doubling multiply-add long|<details><summary>Click here to expand the API list</summary>[vqdmlal_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_s16*)<br/>[vqdmlal_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_s32*)<br/>[vqdmlalh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlalh_s16*)<br/>[vqdmlals_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlals_s32*)<br/>[vqdmlal_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_s16*)<br/>[vqdmlal_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_s32*)<br/></details>|
+|vqdmlal_lane|Vector saturating doubling multiply-accumulate long<br/> with scalar|<details><summary>Click here to expand the API list</summary>[vqdmlal_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_lane_s16*)<br/>[vqdmlal_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_lane_s32*)<br/>[vqdmlal_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_laneq_s16*)<br/>[vqdmlal_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_laneq_s32*)<br/>[vqdmlalh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlalh_lane_s16*)<br/>[vqdmlalh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlalh_laneq_s16*)<br/>[vqdmlals_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlals_lane_s32*)<br/>[vqdmlals_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlals_laneq_s32*)<br/>[vqdmlal_high_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_lane_s16*)<br/>[vqdmlal_high_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_lane_s32*)<br/>[vqdmlal_high_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_laneq_s16*)<br/>[vqdmlal_high_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_laneq_s32*)<br/></details>|
+|vqdmlal_n|Vector saturating doubling multiply-accumulate long<br/> with scalar|<details><summary>Click here to expand the API list</summary>[vqdmlal_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_n_s16*)<br/>[vqdmlal_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_n_s32*)<br/>[vqdmlal_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_n_s16*)<br/>[vqdmlal_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlal_high_n_s32*)<br/></details>|
+|vqdmlsl|Signed saturating doubling multiply-subtract long|<details><summary>Click here to expand the API list</summary>[vqdmlsl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_s16*)<br/>[vqdmlsl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_s32*)<br/>[vqdmlslh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlslh_s16*)<br/>[vqdmlsls_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsls_s32*)<br/>[vqdmlsl_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_s16*)<br/>[vqdmlsl_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_s32*)<br/></details>|
+|vqdmlsl_lane|Vector saturating doubling multiply-subtract long<br/> with scalar|<details><summary>Click here to expand the API list</summary>[vqdmlsl_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_lane_s16*)<br/>[vqdmlsl_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_lane_s32*)<br/>[vqdmlsl_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_laneq_s16*)<br/>[vqdmlsl_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_laneq_s32*)<br/>[vqdmlslh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlslh_lane_s16*)<br/>[vqdmlslh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlslh_laneq_s16*)<br/>[vqdmlsls_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsls_lane_s32*)<br/>[vqdmlsls_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsls_laneq_s32*)<br/>[vqdmlsl_high_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_lane_s16*)<br/>[vqdmlsl_high_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_lane_s32*)<br/>[vqdmlsl_high_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_laneq_s16*)<br/>[vqdmlsl_high_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_laneq_s32*)<br/></details>|
+|vqdmlsl_n|Vector saturating doubling multiply-subtract long<br/> with scalar|<details><summary>Click here to expand the API list</summary>[vqdmlsl_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_n_s16*)<br/>[vqdmlsl_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_n_s32*)<br/>[vqdmlsl_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_n_s16*)<br/>[vqdmlsl_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqdmlsl_high_n_s32*)<br/></details>|
+|vqrdmlah|Saturating rounding doubling multiply accumulate<br/> returning high half (vector)|<details><summary>Click here to expand the API list</summary>[vqrdmlah_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlah_s16*)<br/>[vqrdmlah_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlah_s32*)<br/>[vqrdmlahq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahq_s16*)<br/>[vqrdmlahq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahq_s32*)<br/>[vqrdmlahh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahh_s16*)<br/>[vqrdmlahs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahs_s32*)<br/></details>|
+|vqrdmlah_lane|Saturating rounding doubling multiply accumulate<br/> returning high half (vector)|<details><summary>Click here to expand the API list</summary>[vqrdmlah_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlah_lane_s16*)<br/> [vqrdmlah_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlah_lane_s32*)<br/> [vqrdmlah_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlah_laneq_s16*)<br/> [vqrdmlah_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlah_laneq_s32*)<br/> [vqrdmlahq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahq_lane_s16*)<br/> [vqrdmlahq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahq_lane_s32*)<br/> [vqrdmlahq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahq_laneq_s16*)<br/> [vqrdmlahq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahq_laneq_s32*)<br/> [vqrdmlahh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahh_lane_s16*)<br/> [vqrdmlahh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahh_laneq_s16*)<br/> [vqrdmlahs_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlahs_lane_s32*)<br/></details>|
+|vqrdmlsh|Saturating rounding doubling multiply subtract<br/> returning high half (vector)|<details><summary>Click here to expand the API list</summary>[vqrdmlsh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlsh_s16*)<br/>[vqrdmlsh_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlsh_s32*)<br/>[vqrdmlshq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshq_s16*)<br/>[vqrdmlshq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshq_s32*)<br/>[vqrdmlshh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshh_s16*)<br/>[vqrdmlshs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshs_s32*)<br/></details>|
+|vqrdmlsh_lane|Saturating rounding doubling multiply subtract<br/> returning high half (vector)|<details><summary>Click here to expand the API list</summary>[vqrdmlsh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlsh_lane_s16*)<br/>[vqrdmlsh_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlsh_lane_s32*)<br/>[vqrdmlsh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlsh_laneq_s16*)<br/>[vqrdmlsh_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlsh_laneq_s32*)<br/>[vqrdmlshq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshq_lane_s16*)<br/>[vqrdmlshq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshq_lane_s32*)<br/>[vqrdmlshq_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshq_laneq_s16*)<br/>[vqrdmlshq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshq_laneq_s32*)<br/>[vqrdmlshh_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshh_lane_s16*)<br/>[vqrdmlshh_laneq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshh_laneq_s16*)<br/>[vqrdmlshs_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrdmlshs_lane_s32*)<br/></details>|
+|vfma|Floating-point fused multiply-add to accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vfma_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_f32*)<br/>[vfma_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_f64*)<br/>[vfmaq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_f32*)<br/>[vfmaq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_f64*)<br/></details>|
+|vfma_n|Floating-point fused multiply-add to accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vfma_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_n_f32*)<br/>[vfma_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_n_f64*)<br/>[vfmaq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_n_f32*)<br/>[vfmaq_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_n_f64*)<br/></details>|
+|vfma_lane|Floating-point fused multiply-add to accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vfma_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_lane_f32*)<br/>[vfma_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_lane_f64*)<br/>[vfma_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_laneq_f32*)<br/>[vfma_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfma_laneq_f64*)<br/>[vfmaq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_lane_f32*)<br/>[vfmaq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_lane_f64*)<br/>[vfmaq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_laneq_f32*)<br/>[vfmaq_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmaq_laneq_f64*)<br/>[vfmas_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmas_lane_f32*)<br/>[vfmas_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmas_laneq_f32*)<br/>[vfmad_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmad_lane_f64*)<br/>[vfmad_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmad_laneq_f64*)<br/></details>|
+|vfms|Floating-point fused multiply-subtract<br/> from accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vfms_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_f32*)<br/>[vfms_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_f64*)<br/>[vfmsq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_f32*)<br/>[vfmsq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_f64*)<br/></details>|
+|vfms_n|Floating-point fused multiply-subtract<br/> from accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vfms_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_n_f32*)<br/>[vfms_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_n_f64*)<br/>[vfmsq_n_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_n_f32*)<br/>[vfmsq_n_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_n_f64*)<br/></details>|
+|vfms_lane|Floating-point fused multiply-subtract<br/> from accumulator (vector)|<details><summary>Click here to expand the API list</summary>[vfms_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_lane_f32*)<br/>[vfms_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_lane_f64*)<br/>[vfms_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_laneq_f32*)<br/>[vfms_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfms_laneq_f64*)<br/>[vfmsd_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsd_lane_f64*)<br/>[vfmsd_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsd_laneq_f64*)<br/>[vfmsq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_lane_f32*)<br/>[vfmsq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_lane_f64*)<br/>[vfmsq_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_laneq_f32*)<br/>[vfmsq_laneq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmsq_laneq_f64*)<br/>[vfmss_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmss_lane_f32*)<br/>[vfmss_laneq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vfmss_laneq_f32*)<br/></details>|
+|vdiv|Floating-point divide (vector)|<details><summary>Click here to expand the API list</summary>[vdiv_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdiv_f32*)<br/> [vdiv_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdiv_f64*)<br/> [vdivq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdivq_f32*)<br/> [vdivq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vdivq_f64*)<br/></details>|
+
+### Data processing
+
+|Operation|Description|APIs|
+|---|---|---|
+|vpmax|Maximum pairwise|<details><summary>Click here to expand the API list</summary>[vpmax_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_f32*)<br/>[vpmax_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_s16*)<br/>[vpmax_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_s32*)<br/>[vpmax_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_s8*)<br/>[vpmax_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_u16*)<br/>[vpmax_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_u32*)<br/>[vpmax_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmax_u8*)<br/>[vpmaxq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_f32*)<br/>[vpmaxq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_f64*)<br/>[vpmaxq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_s16*)<br/>[vpmaxq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_s32*)<br/>[vpmaxq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_s8*)<br/>[vpmaxq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_u16*)<br/>[vpmaxq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_u32*)<br/>[vpmaxq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxq_u8*)<br/>[vpmaxs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxs_f32*)<br/>[vpmaxqd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxqd_f64*)<br/></details>|
+|vpmaxnm|Floating-point maximum number pairwise (vector)|<details><summary>Click here to expand the API list</summary>[vpmaxnm_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxnm_f32*)<br/>[vpmaxnmq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxnmq_f32*)<br/>[vpmaxnmq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxnmq_f64*)<br/>[vpmaxnms_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxnms_f32*)<br/>[vpmaxnmqd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmaxnmqd_f64*)<br/></details>|
+|vpmin|Minimum pairwise|<details><summary>Click here to expand the API list</summary>[vpmin_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_f32*)<br/>[vpmin_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_s16*)<br/>[vpmin_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_s32*)<br/>[vpmin_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_s8*)<br/>[vpmin_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_u16*)<br/>[vpmin_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_u32*)<br/>[vpmin_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmin_u8*)<br/>[vpminq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_f32*)<br/>[vpminq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_f64*)<br/>[vpminq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_s16*)<br/>[vpminq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_s32*)<br/>[vpminq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_s8*)<br/>[vpminq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_u16*)<br/>[vpminq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_u32*)<br/>[vpminq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminq_u8*)<br/>[vpmins_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpmins_f32*)<br/>[vpminqd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminqd_f64*)<br/></details>|
+|vpminnm|Floating-point minimum number pairwise (vector)|<details><summary>Click here to expand the API list</summary>[vpminnm_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminnm_f32*)<br/>[vpminnmq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminnmq_f32*)<br/>[vpminnmq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminnmq_f64*)<br/>[vpminnms_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminnms_f32*)<br/>[vpminnmqd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vpminnmqd_f64*)<br/></details>|
+|vabd|Absolute difference|<details><summary>Click here to expand the API list</summary>[vabd_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_f32*)<br/>[vabd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_f64*)<br/>[vabd_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_s16*)<br/>[vabd_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_s32*)<br/>[vabd_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_s8*)<br/>[vabd_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_u16*)<br/>[vabd_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_u32*)<br/>[vabd_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabd_u8*)<br/>[vabdq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_f32*)<br/>[vabdq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_f64*)<br/>[vabdq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_s16*)<br/>[vabdq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_s32*)<br/>[vabdq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_s8*)<br/>[vabdq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_u16*)<br/>[vabdq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_u32*)<br/>[vabdq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdq_u8*)<br/>[vabds_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabds_f32*)<br/>[vabdd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdd_f64*)<br/></details>|
+|vabdl|Absolute difference long|<details><summary>Click here to expand the API list</summary>[vabdl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_s16*)<br/>[vabdl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_s32*)<br/>[vabdl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_s8*)<br/>[vabdl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_u16*)<br/>[vabdl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_u32*)<br/>[vabdl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_u8*)<br/>[vabdl_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_high_s16*)<br/>[vabdl_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_high_s32*)<br/>[vabdl_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_high_s8*)<br/>[vabdl_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_high_u16*)<br/>[vabdl_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_high_u32*)<br/>[vabdl_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabdl_high_u8*)<br/></details>|
+|vaba|Absolute difference and accumulate|<details><summary>Click here to expand the API list</summary>[vaba_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaba_s16*)<br/>[vaba_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaba_s32*)<br/>[vaba_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaba_s8*)<br/>[vaba_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vaba_u16*)<br/>[vaba_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vaba_u32*)<br/>[vaba_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaba_u8*)<br/>[vabaq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabaq_s16*)<br/>[vabaq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabaq_s32*)<br/>[vabaq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabaq_s8*)<br/>[vabaq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabaq_u16*)<br/>[vabaq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabaq_u32*)<br/>[vabaq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabaq_u8*)<br/></details>|
+|vabal|Absolute difference and accumulate long|<details><summary>Click here to expand the API list</summary>[vabal_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_s16*)<br/>[vabal_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_s32*)<br/>[vabal_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_s8*)<br/>[vabal_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_u16*)<br/>[vabal_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_u32*)<br/>[vabal_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_u8*)<br/>[vabal_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_high_s16*)<br/>[vabal_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_high_s32*)<br/>[vabal_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_high_s8*)<br/>[vabal_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_high_u16*)<br/>[vabal_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_high_u32*)<br/>[vabal_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabal_high_u8*)<br/></details>|
+|vmax|Maximum|<details><summary>Click here to expand the API list</summary>[vmax_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_f32*)<br/>[vmax_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_f64*)<br/>[vmax_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_s16*)<br/>[vmax_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_s32*)<br/>[vmax_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_s8*)<br/>[vmax_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_u16*)<br/>[vmax_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_u32*)<br/>[vmax_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmax_u8*)<br/>[vmaxq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_f32*)<br/>[vmaxq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_f64*)<br/>[vmaxq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_s16*)<br/>[vmaxq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_s32*)<br/>[vmaxq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_s8*)<br/>[vmaxq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_u16*)<br/>[vmaxq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_u32*)<br/>[vmaxq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxq_u8*)<br/></details>|
+|vmaxnm|Floating-point maximum number|<details><summary>Click here to expand the API list</summary>[vmaxnm_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnm_f32*)<br/>[vmaxnm_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnm_f64*)<br/>[vmaxnmq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnmq_f32*)<br/>[vmaxnmq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnmq_f64*)<br/>[vmaxnmv_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnmv_f32*)<br/>[vmaxnmvq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnmvq_f32*)<br/>[vmaxnmvq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxnmvq_f64*)<br/></details>|
+|vmaxv|Maximum across vector|<details><summary>Click here to expand the API list</summary>[vmaxv_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_f32*)<br/>[vmaxv_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_s16*)<br/>[vmaxv_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_s32*)<br/>[vmaxv_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_s8*)<br/>[vmaxv_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_u16*)<br/>[vmaxv_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_u32*)<br/>[vmaxv_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxv_u8*)<br/>[vmaxvq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_f32*)<br/>[vmaxvq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_f64*)<br/>[vmaxvq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_s16*)<br/>[vmaxvq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_s32*)<br/>[vmaxvq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_s8*)<br/>[vmaxvq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_u16*)<br/>[vmaxvq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_u32*)<br/>[vmaxvq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmaxvq_u8*)<br/></details>|
+|vmin|Minimum|<details><summary>Click here to expand the API list</summary>[vmin_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_f32*)<br/>[vmin_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_f64*)<br/>[vmin_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_s16*)<br/>[vmin_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_s32*)<br/>[vmin_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_s8*)<br/>[vmin_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_u16*)<br/>[vmin_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_u32*)<br/>[vmin_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmin_u8*)<br/>[vminq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_f32*)<br/>[vminq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_f64*)<br/>[vminq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_s16*)<br/>[vminq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_s32*)<br/>[vminq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_s8*)<br/>[vminq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_u16*)<br/>[vminq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_u32*)<br/>[vminq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vminq_u8*)<br/></details>|
+|vminnm|Floating-point minimum number|<details><summary>Click here to expand the API list</summary>[vminnm_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnm_f32*)<br/>[vminnm_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnm_f64*)<br/>[vminnmq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnmq_f32*)<br/>[vminnmq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnmq_f64*)<br/>[vminnmv_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnmv_f32*)<br/>[vminnmvq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnmvq_f32*)<br/>[vminnmvq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vminnmvq_f64*)<br/></details>|
+|vminv|Minimum across vector|<details><summary>Click here to expand the API list</summary>[vminv_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_f32*)<br/>[vminv_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_s16*)<br/>[vminv_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_s32*)<br/>[vminv_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_s8*)<br/>[vminv_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_u16*)<br/>[vminv_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_u32*)<br/>[vminv_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vminv_u8*)<br/>[vminvq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_f32*)<br/>[vminvq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_f64*)<br/>[vminvq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_s16*)<br/>[vminvq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_s32*)<br/>[vminvq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_s8*)<br/>[vminvq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_u16*)<br/>[vminvq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_u32*)<br/>[vminvq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vminvq_u8*)<br/></details>|
+|vabs|Absolute value|<details><summary>Click here to expand the API list</summary>[vabs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabs_f32*)<br/>[vabs_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabs_f64*)<br/>[vabs_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabs_s16*)<br/>[vabs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabs_s32*)<br/>[vabs_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabs_s64*)<br/>[vabs_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabs_s8*)<br/>[vabsq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsq_f32*)<br/>[vabsq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsq_f64*)<br/>[vabsq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsq_s16*)<br/>[vabsq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsq_s32*)<br/>[vabsq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsq_s64*)<br/>[vabsq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsq_s8*)<br/>[vabsd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vabsd_s64*)<br/></details>|
+|vqabs|Saturating absolute value|<details><summary>Click here to expand the API list</summary>[vqabs_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabs_s16*)<br/>[vqabs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabs_s32*)<br/>[vqabs_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabs_s64*)<br/>[vqabs_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabs_s8*)<br/>[vqabsq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsq_s16*)<br/>[vqabsq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsq_s32*)<br/>[vqabsq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsq_s64*)<br/>[vqabsq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsq_s8*)<br/>[vqabsb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsb_s8*)<br/>[vqabsh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsh_s16*)<br/>[vqabss_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabss_s32*)<br/>[vqabsd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqabsd_s64*)<br/></details>|
+|vneg|Negate|<details><summary>Click here to expand the API list</summary>[vneg_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vneg_f32*)<br/>[vneg_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vneg_f64*)<br/>[vneg_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vneg_s16*)<br/>[vneg_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vneg_s32*)<br/>[vneg_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vneg_s64*)<br/>[vneg_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vneg_s8*)<br/>[vnegd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegd_s64*)<br/>[vnegq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegq_f32*)<br/>[vnegq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegq_f64*)<br/>[vnegq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegq_s16*)<br/>[vnegq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegq_s32*)<br/>[vnegq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegq_s64*)<br/>[vnegq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vnegq_s8*)<br/></details>|
+|vqneg|Saturating negate|<details><summary>Click here to expand the API list</summary>[vqneg_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqneg_s16*)<br/>[vqneg_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqneg_s32*)<br/>[vqneg_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqneg_s64*)<br/>[vqneg_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqneg_s8*)<br/>[vqnegq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegq_s16*)<br/>[vqnegq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegq_s32*)<br/>[vqnegq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegq_s64*)<br/>[vqnegq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegq_s8*)<br/>[vqnegb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegb_s8*)<br/>[vqnegh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegh_s16*)<br/>[vqnegs_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegs_s32*)<br/>[vqnegd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqnegd_s64*)<br/></details>|
+|vcls|Count leading sign bits|<details><summary>Click here to expand the API list</summary>[vcls_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcls_s16*)<br/>[vcls_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcls_s32*)<br/>[vcls_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcls_s8*)<br/>[vclsq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclsq_s16*)<br/>[vclsq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclsq_s32*)<br/>[vclsq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclsq_s8*)<br/></details>|
+|vclz|Count leading zero bits|<details><summary>Click here to expand the API list</summary>[vclz_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclz_s16*)<br/>[vclz_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclz_s32*)<br/>[vclz_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclz_s8*)<br/>[vclz_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclz_u16*)<br/>[vclz_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclz_u32*)<br/>[vclz_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclz_u8*)<br/>[vclzq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclzq_s16*)<br/>[vclzq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclzq_s32*)<br/>[vclzq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclzq_s8*)<br/>[vclzq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclzq_u16*)<br/>[vclzq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclzq_u32*)<br/>[vclzq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclzq_u8*)<br/></details>|
+|vcnt|Population count per byte|<details><summary>Click here to expand the API list</summary>[vcnt_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcnt_s8*)<br/>[vcnt_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcnt_u8*)<br/>[vcntq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcntq_s8*)<br/>[vcntq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcntq_u8*)<br/></details>|
+|vrecpe|Reciprocal estimate|<details><summary>Click here to expand the API list</summary>[vrecpe_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpe_f32*)<br/> [vrecpe_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpe_f64*)<br/> [vrecpe_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpe_u32*)<br/> [vrecpeq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpeq_f32*)<br/> [vrecpeq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpeq_f64*)<br/> [vrecpeq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpeq_u32*)<br/> [vrecpes_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpes_f32*)<br/> [vrecped_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecped_f64*)<br/></details>|
+|vrecps|Reciprocal step|<details><summary>Click here to expand the API list</summary>[vrecps_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecps_f32*)<br/> [vrecps_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecps_f64*)<br/> [vrecpsq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpsq_f32*)<br/> [vrecpsq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpsq_f64*)<br/> [vrecpss_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpss_f32*)<br/> [vrecpsd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpsd_f64*)<br/></details>|
+|vrecpx|Floating-point reciprocal exponent|<details><summary>Click here to expand the API list</summary>[vrecpxd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpxd_f64*)<br/>[vrecpxs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrecpxs_f32*)<br/></details>|
+|vrsqrte|Reciprocal square root estimate|<details><summary>Click here to expand the API list</summary>[vrsqrte_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrte_f32*)<br/> [vrsqrte_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrte_f64*)<br/> [vrsqrte_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrte_u32*)<br/> [vrsqrteq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrteq_f32*)<br/> [vrsqrteq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrteq_f64*)<br/> [vrsqrteq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrteq_u32*)<br/> [vrsqrtes_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrtes_f32*)<br/> [vrsqrted_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrted_f64*)<br/></details>|
+|vrsqrts|Reciprocal square root step|<details><summary>Click here to expand the API list</summary>[vrsqrts_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrts_f32*)<br/> [vrsqrts_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrts_f64*)<br/> [vrsqrtsq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrtsq_f32*)<br/> [vrsqrtsq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrtsq_f64*)<br/> [vrsqrtss_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrtss_f32*)<br/> [vrsqrtsd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsqrtsd_f64*)<br/></details>|
+|vmovn|Extract narrow|<details><summary>Click here to expand the API list</summary>[vmovn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_s16*)<br/>[vmovn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_s32*)<br/>[vmovn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_s64*)<br/>[vmovn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_u16*)<br/>[vmovn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_u32*)<br/>[vmovn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_u64*)<br/>[vmovn_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_high_s16*)<br/>[vmovn_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_high_s32*)<br/>[vmovn_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_high_s64*)<br/>[vmovn_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_high_u16*)<br/>[vmovn_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_high_u32*)<br/>[vmovn_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovn_high_u64*)<br/></details>|
+|vmovl|Extract long|<details><summary>Click here to expand the API list</summary>[vmovl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_s16*)<br/>[vmovl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_s32*)<br/>[vmovl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_s8*)<br/>[vmovl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_u16*)<br/>[vmovl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_u32*)<br/>[vmovl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_u8*)<br/>[vmovl_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_high_s16*)<br/>[vmovl_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_high_s32*)<br/>[vmovl_high_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_high_s8*)<br/>[vmovl_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_high_u16*)<br/>[vmovl_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_high_u32*)<br/>[vmovl_high_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmovl_high_u8*)<br/></details>|
+|vqmovn|Saturating extract narrow|<details><summary>Click here to expand the API list</summary>[vqmovn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_s16*)<br/>[vqmovn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_s32*)<br/>[vqmovn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_s64*)<br/>[vqmovn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_u16*)<br/>[vqmovn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_u32*)<br/>[vqmovn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_u64*)<br/>[vqmovn_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_high_s16*)<br/>[vqmovn_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_high_s32*)<br/>[vqmovn_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_high_s64*)<br/>[vqmovn_high_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_high_u16*)<br/>[vqmovn_high_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_high_u32*)<br/>[vqmovn_high_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovn_high_u64*)<br/>[vqmovnh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovnh_s16*)<br/>[vqmovnh_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovnh_u16*)<br/>[vqmovns_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovns_s32*)<br/>[vqmovns_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovns_u32*)<br/>[vqmovnd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovnd_s64*)<br/>[vqmovnd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovnd_u64*)<br/></details>|
+|vqmovun|Signed saturating extract unsigned narrow|<details><summary>Click here to expand the API list</summary>[vqmovun_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovun_s16*)<br/>[vqmovun_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovun_s32*)<br/>[vqmovun_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovun_s64*)<br/>[vqmovun_high_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovun_high_s16*)<br/>[vqmovun_high_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovun_high_s32*)<br/>[vqmovun_high_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovun_high_s64*)<br/>[vqmovunh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovunh_s16*)<br/>[vqmovuns_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovuns_s32*)<br/>[vqmovund_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqmovund_s64*)<br/></details>|
+
+### Comparison
+
+|Operation|Description|APIs|
+|---|---|---|
+|vceq|Compare bitwise equal|<details><summary>Click here to expand the API list</summary>[vceq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_f32*)<br/>[vceq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_f64*)<br/>[vceq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_s16*)<br/>[vceq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_s32*)<br/>[vceq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_s64*)<br/>[vceq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_s8*)<br/>[vceq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_u16*)<br/>[vceq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_u32*)<br/>[vceq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_u64*)<br/>[vceq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceq_u8*)<br/>[vceqq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_f32*)<br/>[vceqq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_f64*)<br/>[vceqq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_s16*)<br/>[vceqq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_s32*)<br/>[vceqq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_s64*)<br/>[vceqq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_s8*)<br/>[vceqq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_u16*)<br/>[vceqq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_u32*)<br/>[vceqq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_u64*)<br/>[vceqq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqq_u8*)<br/>[vceqs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqs_f32*)<br/>[vceqd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqd_f64*)<br/>[vceqd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqd_s64*)<br/>[vceqd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqd_u64*)<br/></details>|
+|vceqz|Compare bitwise equal to zero|<details><summary>Click here to expand the API list</summary>[vceqz_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_f32*)<br/>[vceqz_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_f64*)<br/>[vceqz_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_s16*)<br/>[vceqz_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_s32*)<br/>[vceqz_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_s64*)<br/>[vceqz_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_s8*)<br/>[vceqz_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_u16*)<br/>[vceqz_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_u32*)<br/>[vceqz_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_u64*)<br/>[vceqz_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqz_u8*)<br/>[vceqzq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_f32*)<br/>[vceqzq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_f64*)<br/>[vceqzq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_s16*)<br/>[vceqzq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_s32*)<br/>[vceqzq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_s64*)<br/>[vceqzq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_s8*)<br/>[vceqzq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_u16*)<br/>[vceqzq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_u32*)<br/>[vceqzq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_u64*)<br/>[vceqzq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzq_u8*)<br/>[vceqzs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzs_f32*)<br/>[vceqzd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzd_f64*)<br/>[vceqzd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzd_s64*)<br/>[vceqzd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vceqzd_u64*)<br/></details>|
+|vcge|Compare greater than or equal|<details><summary>Click here to expand the API list</summary>[vcge_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_f32*)<br/>[vcge_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_f64*)<br/>[vcge_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_s16*)<br/>[vcge_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_s32*)<br/>[vcge_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_s64*)<br/>[vcge_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_s8*)<br/>[vcge_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_u16*)<br/>[vcge_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_u32*)<br/>[vcge_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_u64*)<br/>[vcge_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcge_u8*)<br/>[vcgeq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_f32*)<br/>[vcgeq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_f64*)<br/>[vcgeq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_s16*)<br/>[vcgeq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_s32*)<br/>[vcgeq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_s64*)<br/>[vcgeq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_s8*)<br/>[vcgeq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_u16*)<br/>[vcgeq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_u32*)<br/>[vcgeq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_u64*)<br/>[vcgeq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgeq_u8*)<br/>[vcges_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcges_f32*)<br/>[vcged_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcged_f64*)<br/>[vcged_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcged_s64*)<br/>[vcged_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcged_u64*)<br/></details>|
+|vcgez|Compare greater than or equal to zero|<details><summary>Click here to expand the API list</summary>[vcgez_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgez_f32*)<br/>[vcgez_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgez_f64*)<br/>[vcgez_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgez_s16*)<br/>[vcgez_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgez_s32*)<br/>[vcgez_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgez_s64*)<br/>[vcgez_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgez_s8*)<br/>[vcgezq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezq_f32*)<br/>[vcgezq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezq_f64*)<br/>[vcgezq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezq_s16*)<br/>[vcgezq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezq_s32*)<br/>[vcgezq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezq_s64*)<br/>[vcgezq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezq_s8*)<br/>[vcgezs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezs_f32*)<br/>[vcgezd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezd_f64*)<br/>[vcgezd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgezd_s64*)<br/></details>|
+|vcle|Compare less than or equal|<details><summary>Click here to expand the API list</summary>[vcle_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_f32*)<br/>[vcle_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_f64*)<br/>[vcle_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_s16*)<br/>[vcle_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_s32*)<br/>[vcle_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_s64*)<br/>[vcle_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_s8*)<br/>[vcle_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_u16*)<br/>[vcle_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_u32*)<br/>[vcle_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_u64*)<br/>[vcle_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcle_u8*)<br/>[vcleq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_f32*)<br/>[vcleq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_f64*)<br/>[vcleq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_s16*)<br/>[vcleq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_s32*)<br/>[vcleq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_s64*)<br/>[vcleq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_s8*)<br/>[vcleq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_u16*)<br/>[vcleq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_u32*)<br/>[vcleq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_u64*)<br/>[vcleq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcleq_u8*)<br/>[vcles_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcles_f32*)<br/>[vcled_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcled_f64*)<br/>[vcled_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcled_s64*)<br/>[vcled_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcled_u64*)<br/></details>|
+|vclez|Compare less than or equal to zero|<details><summary>Click here to expand the API list</summary>[vclez_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclez_f32*)<br/>[vclez_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclez_f64*)<br/>[vclez_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclez_s16*)<br/>[vclez_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclez_s32*)<br/>[vclez_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclez_s64*)<br/>[vclez_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclez_s8*)<br/>[vclezq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezq_f32*)<br/>[vclezq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezq_f64*)<br/>[vclezq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezq_s16*)<br/>[vclezq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezq_s32*)<br/>[vclezq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezq_s64*)<br/>[vclezq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezq_s8*)<br/>[vclezs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezs_f32*)<br/>[vclezd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezd_f64*)<br/>[vclezd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclezd_s64*)<br/></details>|
+|vcgt|Compare greater than|<details><summary>Click here to expand the API list</summary>[vcgt_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_f32*)<br/>[vcgt_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_f64*)<br/>[vcgt_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_s16*)<br/>[vcgt_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_s32*)<br/>[vcgt_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_s64*)<br/>[vcgt_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_s8*)<br/>[vcgt_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_u16*)<br/>[vcgt_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_u32*)<br/>[vcgt_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_u64*)<br/>[vcgt_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgt_u8*)<br/>[vcgtq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_f32*)<br/>[vcgtq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_f64*)<br/>[vcgtq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_s16*)<br/>[vcgtq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_s32*)<br/>[vcgtq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_s64*)<br/>[vcgtq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_s8*)<br/>[vcgtq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_u16*)<br/>[vcgtq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_u32*)<br/>[vcgtq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_u64*)<br/>[vcgtq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtq_u8*)<br/>[vcgts_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgts_f32*)<br/>[vcgtd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtd_f64*)<br/>[vcgtd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtd_s64*)<br/>[vcgtd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtd_u64*)<br/></details>|
+|vcgtz|Compare greater than zero|<details><summary>Click here to expand the API list</summary>[vcgtz_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtz_f32*)<br/>[vcgtz_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtz_f64*)<br/>[vcgtz_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtz_s16*)<br/>[vcgtz_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtz_s32*)<br/>[vcgtz_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtz_s64*)<br/>[vcgtz_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtz_s8*)<br/>[vcgtzq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzq_f32*)<br/>[vcgtzq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzq_f64*)<br/>[vcgtzq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzq_s16*)<br/>[vcgtzq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzq_s32*)<br/>[vcgtzq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzq_s64*)<br/>[vcgtzq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzq_s8*)<br/>[vcgtzs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzs_f32*)<br/>[vcgtzd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzd_f64*)<br/>[vcgtzd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcgtzd_s64*)<br/></details>|
+|vclt|Compare less than|<details><summary>Click here to expand the API list</summary>[vclt_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_f32*)<br/>[vclt_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_f64*)<br/>[vclt_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_s16*)<br/>[vclt_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_s32*)<br/>[vclt_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_s64*)<br/>[vclt_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_s8*)<br/>[vclt_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_u16*)<br/>[vclt_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_u32*)<br/>[vclt_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_u64*)<br/>[vclt_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vclt_u8*)<br/>[vcltq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_f32*)<br/>[vcltq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_f64*)<br/>[vcltq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_s16*)<br/>[vcltq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_s32*)<br/>[vcltq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_s64*)<br/>[vcltq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_s8*)<br/>[vcltq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_u16*)<br/>[vcltq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_u32*)<br/>[vcltq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_u64*)<br/>[vcltq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltq_u8*)<br/>[vclts_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vclts_f32*)<br/>[vcltd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltd_f64*)<br/>[vcltd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltd_s64*)<br/>[vcltd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltd_u64*)<br/></details>|
+|vcltz|Compare less than zero|<details><summary>Click here to expand the API list</summary>[vcltz_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltz_f32*)<br/>[vcltz_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltz_f64*)<br/>[vcltz_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltz_s16*)<br/>[vcltz_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltz_s32*)<br/>[vcltz_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltz_s64*)<br/>[vcltz_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltz_s8*)<br/>[vcltzq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzq_f32*)<br/>[vcltzq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzq_f64*)<br/>[vcltzq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzq_s16*)<br/>[vcltzq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzq_s32*)<br/>[vcltzq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzq_s64*)<br/>[vcltzq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzq_s8*)<br/>[vcltzs_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzs_f32*)<br/>[vcltzd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzd_f64*)<br/>[vcltzd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcltzd_s64*)<br/></details>|
+|vcage|Floating-point absolute compare greater than or equal|<details><summary>Click here to expand the API list</summary>[vcage_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcage_f32*)<br/>[vcage_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcage_f64*)<br/>[vcageq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcageq_f32*)<br/>[vcageq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcageq_f64*)<br/>[vcages_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcages_f32*)<br/>[vcaged_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaged_f64*)<br/></details>|
+|vcagt|Floating-point absolute compare greater than|<details><summary>Click here to expand the API list</summary>[vcagt_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcagt_f32*)<br/>[vcagt_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcagt_f64*)<br/>[vcagtq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcagtq_f32*)<br/>[vcagtq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcagtq_f64*)<br/>[vcagts_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcagts_f32*)<br/>[vcagtd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcagtd_f64*)<br/></details>|
+|vcale|Floating-point absolute compare less than or equal|<details><summary>Click here to expand the API list</summary>[vcale_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcale_f32*)<br/>[vcale_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcale_f64*)<br/>[vcaleq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaleq_f32*)<br/>[vcaleq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaleq_f64*)<br/>[vcales_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcales_f32*)<br/>[vcaled_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaled_f64*)<br/></details>|
+|vcalt|Floating-point absolute compare less than|<details><summary>Click here to expand the API list</summary>[vcalt_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcalt_f32*)<br/>[vcalt_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcalt_f64*)<br/>[vcaltq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaltq_f32*)<br/>[vcaltq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaltq_f64*)<br/>[vcalts_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcalts_f32*)<br/>[vcaltd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcaltd_f64*)<br/></details>|
+
+### Bitwise
+
+|Operation|Description|APIs|
+|---|---|---|
+|vtst|Test bits nonzero|<details><summary>Click here to expand the API list</summary>[vtst_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_s16*)<br/>[vtst_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_s32*)<br/>[vtst_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_s64*)<br/>[vtst_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_s8*)<br/>[vtst_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_u16*)<br/>[vtst_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_u32*)<br/>[vtst_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_u64*)<br/>[vtst_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtst_u8*)<br/>[vtstd_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstd_s64*)<br/>[vtstd_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstd_u64*)<br/>[vtstq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_s16*)<br/>[vtstq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_s32*)<br/>[vtstq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_s64*)<br/>[vtstq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_s8*)<br/>[vtstq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_u16*)<br/>[vtstq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_u32*)<br/>[vtstq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_u64*)<br/>[vtstq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtstq_u8*)<br/></details>|
+|vmvn|Bitwise NOT|<details><summary>Click here to expand the API list</summary>[vmvn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvn_s16*)<br/>[vmvn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvn_s32*)<br/>[vmvn_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvn_s8*)<br/>[vmvn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvn_u16*)<br/>[vmvn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvn_u32*)<br/>[vmvn_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvn_u8*)<br/>[vmvnq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvnq_s16*)<br/>[vmvnq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvnq_s32*)<br/>[vmvnq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvnq_s8*)<br/>[vmvnq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvnq_u16*)<br/>[vmvnq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvnq_u32*)<br/>[vmvnq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vmvnq_u8*)<br/></details>|
+|vand|Bitwise AND|<details><summary>Click here to expand the API list</summary>[vand_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_s16*)<br/>[vand_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_s32*)<br/>[vand_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_s64*)<br/>[vand_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_s8*)<br/>[vand_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_u16*)<br/>[vand_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_u32*)<br/>[vand_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_u64*)<br/>[vand_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vand_u8*)<br/>[vandq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_s16*)<br/>[vandq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_s32*)<br/>[vandq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_s64*)<br/>[vandq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_s8*)<br/>[vandq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_u16*)<br/>[vandq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_u32*)<br/>[vandq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_u64*)<br/>[vandq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vandq_u8*)<br/></details>|
+|vorr|Bitwise OR|<details><summary>Click here to expand the API list</summary>[vorr_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_s16*)<br/>[vorr_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_s32*)<br/>[vorr_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_s64*)<br/>[vorr_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_s8*)<br/>[vorr_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_u16*)<br/>[vorr_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_u32*)<br/>[vorr_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_u64*)<br/>[vorr_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vorr_u8*)<br/>[vorrq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_s16*)<br/>[vorrq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_s32*)<br/>[vorrq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_s64*)<br/>[vorrq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_s8*)<br/>[vorrq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_u16*)<br/>[vorrq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_u32*)<br/>[vorrq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_u64*)<br/>[vorrq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vorrq_u8*)<br/></details>|
+|vorn|Bitwise OR NOT|<details><summary>Click here to expand the API list</summary>[vorn_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_s16*)<br/>[vorn_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_s32*)<br/>[vorn_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_s64*)<br/>[vorn_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_s8*)<br/>[vorn_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_u16*)<br/>[vorn_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_u32*)<br/>[vorn_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_u64*)<br/>[vorn_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vorn_u8*)<br/>[vornq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_s16*)<br/>[vornq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_s32*)<br/>[vornq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_s64*)<br/>[vornq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_s8*)<br/>[vornq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_u16*)<br/>[vornq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_u32*)<br/>[vornq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_u64*)<br/>[vornq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vornq_u8*)<br/></details>|
+|veor|Bitwise exclusive OR|<details><summary>Click here to expand the API list</summary>[veor_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_s16*)<br/>[veor_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_s32*)<br/>[veor_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_s64*)<br/>[veor_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_s8*)<br/>[veor_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_u16*)<br/>[veor_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_u32*)<br/>[veor_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_u64*)<br/>[veor_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.veor_u8*)<br/>[veorq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_s16*)<br/>[veorq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_s32*)<br/>[veorq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_s64*)<br/>[veorq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_s8*)<br/>[veorq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_u16*)<br/>[veorq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_u32*)<br/>[veorq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_u64*)<br/>[veorq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.veorq_u8*)<br/></details>|
+|vbic|Bitwise bit clear|<details><summary>Click here to expand the API list</summary>[vbic_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_s16*)<br/>[vbic_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_s32*)<br/>[vbic_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_s64*)<br/>[vbic_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_s8*)<br/>[vbic_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_u16*)<br/>[vbic_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_u32*)<br/>[vbic_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_u64*)<br/>[vbic_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbic_u8*)<br/>[vbicq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_s16*)<br/>[vbicq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_s32*)<br/>[vbicq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_s64*)<br/>[vbicq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_s8*)<br/>[vbicq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_u16*)<br/>[vbicq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_u32*)<br/>[vbicq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_u64*)<br/>[vbicq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbicq_u8*)<br/></details>|
+|vbsl|Bitwise select|<details><summary>Click here to expand the API list</summary>[vbsl_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_f32*)<br/>[vbsl_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_f64*)<br/>[vbsl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_s16*)<br/>[vbsl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_s32*)<br/>[vbsl_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_s64*)<br/>[vbsl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_s8*)<br/>[vbsl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_u16*)<br/>[vbsl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_u32*)<br/>[vbsl_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_u64*)<br/>[vbsl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbsl_u8*)<br/>[vbslq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_f32*)<br/>[vbslq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_f64*)<br/>[vbslq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_s16*)<br/>[vbslq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_s32*)<br/>[vbslq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_s64*)<br/>[vbslq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_s8*)<br/>[vbslq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_u16*)<br/>[vbslq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_u32*)<br/>[vbslq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_u64*)<br/>[vbslq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vbslq_u8*)<br/></details>|
+
+### Shift
+
+|Operation|Description|APIs|
+|---|---|---|
+|vshl|Shift left (register)|<details><summary>Click here to expand the API list</summary>[vshl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_s16*)<br/>[vshl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_s32*)<br/>[vshl_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_s64*)<br/>[vshl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_s8*)<br/>[vshl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_u16*)<br/>[vshl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_u32*)<br/>[vshl_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_u64*)<br/>[vshl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_u8*)<br/>[vshlq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_s16*)<br/>[vshlq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_s32*)<br/>[vshlq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_s64*)<br/>[vshlq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_s8*)<br/>[vshlq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_u16*)<br/>[vshlq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_u32*)<br/>[vshlq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_u64*)<br/>[vshlq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_u8*)<br/>[vshld_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshld_s64*)<br/>[vshld_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshld_u64*)<br/></details>|
+|vqshl|Saturating shift left (register)|<details><summary>Click here to expand the API list</summary>[vqshl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_s16*)<br/>[vqshl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_s32*)<br/>[vqshl_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_s64*)<br/>[vqshl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_s8*)<br/>[vqshl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_u16*)<br/>[vqshl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_u32*)<br/>[vqshl_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_u64*)<br/>[vqshl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_u8*)<br/>[vqshlq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_s16*)<br/>[vqshlq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_s32*)<br/>[vqshlq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_s64*)<br/>[vqshlq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_s8*)<br/>[vqshlq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_u16*)<br/>[vqshlq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_u32*)<br/>[vqshlq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_u64*)<br/>[vqshlq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_u8*)<br/>[vqshlb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlb_s8*)<br/>[vqshlb_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlb_u8*)<br/>[vqshlh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlh_s16*)<br/>[vqshlh_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlh_u16*)<br/>[vqshls_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshls_s32*)<br/>[vqshls_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshls_u32*)<br/>[vqshld_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshld_s64*)<br/>[vqshld_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshld_u64*)<br/></details>|
+|vqshl_n|Saturating shift left (immediate)|<details><summary>Click here to expand the API list</summary>[vqshl_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_s16*)<br/>[vqshl_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_s32*)<br/>[vqshl_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_s64*)<br/>[vqshl_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_s8*)<br/>[vqshl_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_u16*)<br/>[vqshl_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_u32*)<br/>[vqshl_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_u64*)<br/>[vqshl_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshl_n_u8*)<br/>[vqshlq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_s16*)<br/>[vqshlq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_s32*)<br/>[vqshlq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_s64*)<br/>[vqshlq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_s8*)<br/>[vqshlq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_u16*)<br/>[vqshlq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_u32*)<br/>[vqshlq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_u64*)<br/>[vqshlq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlq_n_u8*)<br/>[vqshlb_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlb_n_s8*)<br/>[vqshlb_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlb_n_u8*)<br/>[vqshlh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlh_n_s16*)<br/>[vqshlh_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlh_n_u16*)<br/>[vqshls_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshls_n_s32*)<br/>[vqshls_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshls_n_u32*)<br/>[vqshld_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshld_n_s64*)<br/>[vqshld_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshld_n_u64*)<br/></details>|
+|vqshlu_n|Saturating shift left unsigned (immediate)|<details><summary>Click here to expand the API list</summary>[vqshlu_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlu_n_s16*)<br/>[vqshlu_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlu_n_s32*)<br/>[vqshlu_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlu_n_s64*)<br/>[vqshlu_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlu_n_s8*)<br/>[vqshlub_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlub_n_s8*)<br/>[vqshlud_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlud_n_s64*)<br/>[vqshluh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshluh_n_s16*)<br/>[vqshluq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshluq_n_s16*)<br/>[vqshluq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshluq_n_s32*)<br/>[vqshluq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshluq_n_s64*)<br/>[vqshluq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshluq_n_s8*)<br/>[vqshlus_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshlus_n_s32*)<br/></details>|
+|vrshl|Rounding shift left (register)|<details><summary>Click here to expand the API list</summary>[vrshl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_s16*)<br/>[vrshl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_s32*)<br/>[vrshl_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_s64*)<br/>[vrshl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_s8*)<br/>[vrshl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_u16*)<br/>[vrshl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_u32*)<br/>[vrshl_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_u64*)<br/>[vrshl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshl_u8*)<br/>[vrshlq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_s16*)<br/>[vrshlq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_s32*)<br/>[vrshlq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_s64*)<br/>[vrshlq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_s8*)<br/>[vrshlq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_u16*)<br/>[vrshlq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_u32*)<br/>[vrshlq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_u64*)<br/>[vrshlq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshlq_u8*)<br/>[vrshld_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshld_s64*)<br/>[vrshld_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshld_u64*)<br/></details>|
+|vqrshl|Saturating rounding shift left (register)|<details><summary>Click here to expand the API list</summary>[vqrshl_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_s16*)<br/>[vqrshl_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_s32*)<br/>[vqrshl_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_s64*)<br/>[vqrshl_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_s8*)<br/>[vqrshl_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_u16*)<br/>[vqrshl_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_u32*)<br/>[vqrshl_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_u64*)<br/>[vqrshl_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshl_u8*)<br/>[vqrshlq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_s16*)<br/>[vqrshlq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_s32*)<br/>[vqrshlq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_s64*)<br/>[vqrshlq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_s8*)<br/>[vqrshlq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_u16*)<br/>[vqrshlq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_u32*)<br/>[vqrshlq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_u64*)<br/>[vqrshlq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlq_u8*)<br/>[vqrshlb_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlb_s8*)<br/>[vqrshlb_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlb_u8*)<br/>[vqrshlh_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlh_s16*)<br/>[vqrshlh_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshlh_u16*)<br/>[vqrshls_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshls_s32*)<br/>[vqrshls_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshls_u32*)<br/>[vqrshld_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshld_s64*)<br/>[vqrshld_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshld_u64*)<br/></details>|
+|vshl_n|Shift left (immediate)|<details><summary>Click here to expand the API list</summary>[vshl_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_s16*)<br/>[vshl_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_s32*)<br/>[vshl_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_s64*)<br/>[vshl_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_s8*)<br/>[vshl_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_u16*)<br/>[vshl_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_u32*)<br/>[vshl_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_u64*)<br/>[vshl_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshl_n_u8*)<br/>[vshlq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_s16*)<br/>[vshlq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_s32*)<br/>[vshlq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_s64*)<br/>[vshlq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_s8*)<br/>[vshlq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_u16*)<br/>[vshlq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_u32*)<br/>[vshlq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_u64*)<br/>[vshlq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshlq_n_u8*)<br/>[vshld_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshld_n_s64*)<br/>[vshld_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshld_n_u64*)<br/></details>|
+|vshll_n|Shift left long (immediate)|<details><summary>Click here to expand the API list</summary>[vshll_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_n_s16*)<br/>[vshll_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_n_s32*)<br/>[vshll_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_n_s8*)<br/>[vshll_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_n_u16*)<br/>[vshll_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_n_u32*)<br/>[vshll_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_n_u8*)<br/>[vshll_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_high_n_s16*)<br/>[vshll_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_high_n_s32*)<br/>[vshll_high_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_high_n_s8*)<br/>[vshll_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_high_n_u16*)<br/>[vshll_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_high_n_u32*)<br/>[vshll_high_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshll_high_n_u8*)<br/></details>|
+|vshr_n|Shift right (immediate)|<details><summary>Click here to expand the API list</summary>[vshr_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_s16*)<br/>[vshr_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_s32*)<br/>[vshr_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_s64*)<br/>[vshr_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_s8*)<br/>[vshr_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_u16*)<br/>[vshr_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_u32*)<br/>[vshr_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_u64*)<br/>[vshr_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshr_n_u8*)<br/>[vshrq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_s16*)<br/>[vshrq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_s32*)<br/>[vshrq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_s64*)<br/>[vshrq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_s8*)<br/>[vshrq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_u16*)<br/>[vshrq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_u32*)<br/>[vshrq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_u64*)<br/>[vshrq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrq_n_u8*)<br/>[vshrd_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrd_n_s64*)<br/>[vshrd_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrd_n_u64*)<br/></details>|
+|vrshr_n|Rounding right left (register)|<details><summary>Click here to expand the API list</summary>[vrshr_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_s16*)<br/>[vrshr_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_s32*)<br/>[vrshr_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_s64*)<br/>[vrshr_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_s8*)<br/>[vrshr_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_u16*)<br/>[vrshr_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_u32*)<br/>[vrshr_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_u64*)<br/>[vrshr_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshr_n_u8*)<br/>[vrshrq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_s16*)<br/>[vrshrq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_s32*)<br/>[vrshrq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_s64*)<br/>[vrshrq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_s8*)<br/>[vrshrq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_u16*)<br/>[vrshrq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_u32*)<br/>[vrshrq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_u64*)<br/>[vrshrq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrq_n_u8*)<br/>[vrshrd_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrd_n_s64*)<br/>[vrshrd_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrd_n_u64*)<br/></details>|
+|vshrn_n|Shift right narrow (immediate)|<details><summary>Click here to expand the API list</summary>[vshrn_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_n_s16*)<br/>[vshrn_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_n_s32*)<br/>[vshrn_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_n_s64*)<br/>[vshrn_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_n_u16*)<br/>[vshrn_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_n_u32*)<br/>[vshrn_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_n_u64*)<br/>[vshrn_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_high_n_s16*)<br/>[vshrn_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_high_n_s32*)<br/>[vshrn_high_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_high_n_s64*)<br/>[vshrn_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_high_n_u16*)<br/>[vshrn_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_high_n_u32*)<br/>[vshrn_high_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vshrn_high_n_u64*)<br/></details>|
+|vqshrun_n|Signed saturating shift right<br/> unsigned narrow (immediate)|<details><summary>Click here to expand the API list</summary>[vqshrun_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrun_n_s16*)<br/> [vqshrun_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrun_n_s32*)<br/> [vqshrun_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrun_n_s64*)<br/> [vqshrunh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrunh_n_s16*)<br/> [vqshruns_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshruns_n_s32*)<br/> [vqshrund_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrund_n_s64*)<br/> [vqshrun_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrun_high_n_s16*)<br/> [vqshrun_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrun_high_n_s32*)<br/> [vqshrun_high_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrun_high_n_s64*)<br/></details>|
+|vqrshrun_n|Signed saturating rounded shift right<br/> unsigned narrow (immediate)|<details><summary>Click here to expand the API list</summary>[vqrshrun_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrun_n_s16*)<br/> [vqrshrun_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrun_n_s32*)<br/> [vqrshrun_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrun_n_s64*)<br/> [vqrshrunh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrunh_n_s16*)<br/> [vqrshruns_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshruns_n_s32*)<br/> [vqrshrund_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrund_n_s64*)<br/> [vqrshrun_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrun_high_n_s16*)<br/> [vqrshrun_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrun_high_n_s32*)<br/> [vqrshrun_high_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrun_high_n_s64*)<br/></details>|
+|vqshrn_n|Signed saturating shift right narrow (immediate)|<details><summary>Click here to expand the API list</summary>[vqshrn_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_n_s16*)<br/>[vqshrn_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_n_s32*)<br/>[vqshrn_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_n_s64*)<br/>[vqshrn_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_n_u16*)<br/>[vqshrn_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_n_u32*)<br/>[vqshrn_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_n_u64*)<br/>[vqshrnh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrnh_n_s16*)<br/>[vqshrnh_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrnh_n_u16*)<br/>[vqshrns_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrns_n_s32*)<br/>[vqshrns_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrns_n_u32*)<br/>[vqshrnd_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrnd_n_s64*)<br/>[vqshrnd_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrnd_n_u64*)<br/>[vqshrn_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_high_n_s16*)<br/>[vqshrn_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_high_n_s32*)<br/>[vqshrn_high_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_high_n_s64*)<br/>[vqshrn_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_high_n_u16*)<br/>[vqshrn_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_high_n_u32*)<br/>[vqshrn_high_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqshrn_high_n_u64*)<br/></details>|
+|vrshrn_n|Rounding shift right narrow (immediate)|<details><summary>Click here to expand the API list</summary>[vrshrn_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_n_s16*)<br/>[vrshrn_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_n_s32*)<br/>[vrshrn_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_n_s64*)<br/>[vrshrn_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_n_u16*)<br/>[vrshrn_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_n_u32*)<br/>[vrshrn_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_n_u64*)<br/>[vrshrn_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_high_n_s16*)<br/>[vrshrn_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_high_n_s32*)<br/>[vrshrn_high_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_high_n_s64*)<br/>[vrshrn_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_high_n_u16*)<br/>[vrshrn_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_high_n_u32*)<br/>[vrshrn_high_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrshrn_high_n_u64*)<br/></details>|
+|vqrshrn_n|Signed saturating rounded shift right narrow (immediate)|<details><summary>Click here to expand the API list</summary>[vqrshrn_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_n_s16*)<br/> [vqrshrn_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_n_s32*)<br/> [vqrshrn_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_n_s64*)<br/> [vqrshrn_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_n_u16*)<br/> [vqrshrn_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_n_u32*)<br/> [vqrshrn_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_n_u64*)<br/> [vqrshrnh_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrnh_n_s16*)<br/> [vqrshrnh_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrnh_n_u16*)<br/> [vqrshrns_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrns_n_s32*)<br/> [vqrshrns_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrns_n_u32*)<br/> [vqrshrnd_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrnd_n_s64*)<br/> [vqrshrnd_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrnd_n_u64*)<br/> [vqrshrn_high_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_high_n_s16*)<br/> [vqrshrn_high_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_high_n_s32*)<br/> [vqrshrn_high_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_high_n_s64*)<br/> [vqrshrn_high_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_high_n_u16*)<br/> [vqrshrn_high_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_high_n_u32*)<br/> [vqrshrn_high_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vqrshrn_high_n_u64*)<br/></details>|
+|vsra_n|Signed shift right and accumulate (immediate)|<details><summary>Click here to expand the API list</summary>[vsra_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_s16*)<br/>[vsra_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_s32*)<br/>[vsra_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_s64*)<br/>[vsra_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_s8*)<br/>[vsra_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_u16*)<br/>[vsra_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_u32*)<br/>[vsra_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_u64*)<br/>[vsra_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsra_n_u8*)<br/>[vsraq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_s16*)<br/>[vsraq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_s32*)<br/>[vsraq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_s64*)<br/>[vsraq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_s8*)<br/>[vsraq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_u16*)<br/>[vsraq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_u32*)<br/>[vsraq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_u64*)<br/>[vsraq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsraq_n_u8*)<br/>[vsrad_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsrad_n_s64*)<br/>[vsrad_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsrad_n_u64*)<br/></details>|
+|vrsra_n|Signed rounding shift right and accumulate (immediate)|<details><summary>Click here to expand the API list</summary>[vrsra_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_s16*)<br/>[vrsra_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_s32*)<br/>[vrsra_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_s64*)<br/>[vrsra_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_s8*)<br/>[vrsra_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_u16*)<br/>[vrsra_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_u32*)<br/>[vrsra_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_u64*)<br/>[vrsra_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsra_n_u8*)<br/>[vrsraq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_s16*)<br/>[vrsraq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_s32*)<br/>[vrsraq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_s64*)<br/>[vrsraq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_s8*)<br/>[vrsraq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_u16*)<br/>[vrsraq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_u32*)<br/>[vrsraq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_u64*)<br/>[vrsraq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsraq_n_u8*)<br/>[vrsrad_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsrad_n_s64*)<br/>[vrsrad_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrsrad_n_u64*)<br/></details>|
+|vsri_n|Shift right and insert (immediate)|<details><summary>Click here to expand the API list</summary>[vsri_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_s16*)<br/>[vsri_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_s32*)<br/>[vsri_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_s64*)<br/>[vsri_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_s8*)<br/>[vsri_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_u16*)<br/>[vsri_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_u32*)<br/>[vsri_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_u64*)<br/>[vsri_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsri_n_u8*)<br/>[vsriq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_s16*)<br/>[vsriq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_s32*)<br/>[vsriq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_s64*)<br/>[vsriq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_s8*)<br/>[vsriq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_u16*)<br/>[vsriq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_u32*)<br/>[vsriq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_u64*)<br/>[vsriq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsriq_n_u8*)<br/>[vsrid_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsrid_n_s64*)<br/>[vsrid_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsrid_n_u64*)<br/></details>|
+|vsli_n|Shift left and insert (immediate)|<details><summary>Click here to expand the API list</summary>[vsli_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_s16*)<br/>[vsli_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_s32*)<br/>[vsli_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_s64*)<br/>[vsli_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_s8*)<br/>[vsli_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_u16*)<br/>[vsli_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_u32*)<br/>[vsli_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_u64*)<br/>[vsli_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsli_n_u8*)<br/>[vsliq_n_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_s16*)<br/>[vsliq_n_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_s32*)<br/>[vsliq_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_s64*)<br/>[vsliq_n_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_s8*)<br/>[vsliq_n_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_u16*)<br/>[vsliq_n_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_u32*)<br/>[vsliq_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_u64*)<br/>[vsliq_n_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsliq_n_u8*)<br/>[vslid_n_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vslid_n_s64*)<br/>[vslid_n_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vslid_n_u64*)<br/></details>|
+
+### Floating-point
+
+|Operation|Description|APIs|
+|---|---|---|
+|vcvt|Convert to/from another precision or fixed point,<br/>rounding towards zero|<details><summary>Click here to expand the API list</summary>[vcvt_f32_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_f32_f64*)<br/>[vcvt_f32_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_f32_s32*)<br/>[vcvt_f32_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_f32_u32*)<br/>[vcvt_f64_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_f64_f32*)<br/>[vcvt_f64_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_f64_s64*)<br/>[vcvt_f64_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_f64_u64*)<br/>[vcvt_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_s32_f32*)<br/>[vcvt_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_s64_f64*)<br/>[vcvt_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_u32_f32*)<br/>[vcvt_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_u64_f64*)<br/>[vcvtq_f32_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_f32_s32*)<br/>[vcvtq_f32_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_f32_u32*)<br/>[vcvtq_f64_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_f64_s64*)<br/>[vcvtq_f64_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_f64_u64*)<br/>[vcvtq_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_s32_f32*)<br/>[vcvtq_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_s64_f64*)<br/>[vcvtq_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_u32_f32*)<br/>[vcvtq_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_u64_f64*)<br/>[vcvts_f32_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_f32_s32*)<br/>[vcvts_f32_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_f32_u32*)<br/>[vcvts_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_s32_f32*)<br/>[vcvts_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_u32_f32*)<br/>[vcvtd_f64_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_f64_s64*)<br/>[vcvtd_f64_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_f64_u64*)<br/>[vcvtd_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_s64_f64*)<br/>[vcvtd_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_u64_f64*)<br/>[vcvt_high_f32_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_high_f32_f64*)<br/>[vcvt_high_f64_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_high_f64_f32*)<br/></details>|
+|vcvta|Convert to integer, rounding to nearest with ties to away|<details><summary>Click here to expand the API list</summary>[vcvta_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvta_s32_f32*)<br/>[vcvta_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvta_s64_f64*)<br/>[vcvta_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvta_u32_f32*)<br/>[vcvta_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvta_u64_f64*)<br/>[vcvtad_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtad_s64_f64*)<br/>[vcvtad_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtad_u64_f64*)<br/>[vcvtaq_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtaq_s32_f32*)<br/>[vcvtaq_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtaq_s64_f64*)<br/>[vcvtaq_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtaq_u32_f32*)<br/>[vcvtaq_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtaq_u64_f64*)<br/>[vcvtas_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtas_s32_f32*)<br/>[vcvtas_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtas_u32_f32*)<br/></details>|
+|vcvtm|Convert to integer, rounding towards minus infinity|<details><summary>Click here to expand the API list</summary>[vcvtm_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtm_s32_f32*)<br/>[vcvtm_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtm_s64_f64*)<br/>[vcvtm_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtm_u32_f32*)<br/>[vcvtm_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtm_u64_f64*)<br/>[vcvtmq_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtmq_s32_f32*)<br/>[vcvtmq_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtmq_s64_f64*)<br/>[vcvtmq_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtmq_u32_f32*)<br/>[vcvtmq_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtmq_u64_f64*)<br/>[vcvtms_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtms_s32_f32*)<br/>[vcvtms_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtms_u32_f32*)<br/>[vcvtmd_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtmd_s64_f64*)<br/>[vcvtmd_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtmd_u64_f64*)<br/></details>|
+|vcvtn|Convert to integer, rounding to nearest with ties to even|<details><summary>Click here to expand the API list</summary>[vcvtn_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtn_s32_f32*)<br/>[vcvtn_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtn_s64_f64*)<br/>[vcvtn_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtn_u32_f32*)<br/>[vcvtn_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtn_u64_f64*)<br/>[vcvtnq_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtnq_s32_f32*)<br/>[vcvtnq_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtnq_s64_f64*)<br/>[vcvtnq_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtnq_u32_f32*)<br/>[vcvtnq_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtnq_u64_f64*)<br/>[vcvtns_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtns_s32_f32*)<br/>[vcvtns_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtns_u32_f32*)<br/>[vcvtnd_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtnd_s64_f64*)<br/>[vcvtnd_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtnd_u64_f64*)<br/></details>|
+|vcvtp|Convert to integer, rounding towards plus infinity|<details><summary>Click here to expand the API list</summary>[vcvtp_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtp_s32_f32*)<br/>[vcvtp_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtp_s64_f64*)<br/>[vcvtp_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtp_u32_f32*)<br/>[vcvtp_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtp_u64_f64*)<br/>[vcvtpq_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtpq_s32_f32*)<br/>[vcvtpq_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtpq_s64_f64*)<br/>[vcvtpq_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtpq_u32_f32*)<br/>[vcvtpq_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtpq_u64_f64*)<br/>[vcvtps_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtps_s32_f32*)<br/>[vcvtps_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtps_u32_f32*)<br/>[vcvtpd_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtpd_s64_f64*)<br/>[vcvtpd_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtpd_u64_f64*)<br/></details>|
+|vcvtx|Convert to lower precision,<br/> rounding to nearest with ties to odd|<details><summary>Click here to expand the API list</summary>[vcvtx_f32_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtx_f32_f64*)<br/>[vcvtx_high_f32_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtx_high_f32_f64*)<br/>[vcvtxd_f32_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtxd_f32_f64*)<br/></details>|
+|vcvt_n|Convert to/from fixed point, rounding towards zero|<details><summary>Click here to expand the API list</summary>[vcvt_n_f32_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_f32_s32*)<br/>[vcvt_n_f32_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_f32_u32*)<br/>[vcvt_n_f64_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_f64_s64*)<br/>[vcvt_n_f64_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_f64_u64*)<br/>[vcvt_n_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_s32_f32*)<br/>[vcvt_n_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_s64_f64*)<br/>[vcvt_n_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_u32_f32*)<br/>[vcvt_n_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvt_n_u64_f64*)<br/>[vcvtq_n_f32_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_f32_s32*)<br/>[vcvtq_n_f32_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_f32_u32*)<br/>[vcvtq_n_f64_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_f64_s64*)<br/>[vcvtq_n_f64_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_f64_u64*)<br/>[vcvtq_n_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_s32_f32*)<br/>[vcvtq_n_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_s64_f64*)<br/>[vcvtq_n_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_u32_f32*)<br/>[vcvtq_n_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtq_n_u64_f64*)<br/>[vcvts_n_f32_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_n_f32_s32*)<br/>[vcvts_n_f32_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_n_f32_u32*)<br/>[vcvts_n_s32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_n_s32_f32*)<br/>[vcvts_n_u32_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvts_n_u32_f32*)<br/>[vcvtd_n_f64_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_n_f64_s64*)<br/>[vcvtd_n_f64_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_n_f64_u64*)<br/>[vcvtd_n_s64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_n_s64_f64*)<br/>[vcvtd_n_u64_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vcvtd_n_u64_f64*)<br/></details>|
+|vrnd|Round to Integral, toward zero|<details><summary>Click here to expand the API list</summary>[vrnd_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrnd_f32*)<br/> [vrnd_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrnd_f64*)<br/> [vrndq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndq_f32*)<br/> [vrndq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndq_f64*)<br/></details>|
+|vrnda|Round to Integral, with ties to away|<details><summary>Click here to expand the API list</summary>[vrnda_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrnda_f32*)<br/> [vrnda_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrnda_f64*)<br/> [vrndaq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndaq_f32*)<br/> [vrndaq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndaq_f64*)<br/></details>|
+|vrndi|Round to Integral, using current rounding mode|<details><summary>Click here to expand the API list</summary>[vrndi_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndi_f32*)<br/> [vrndi_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndi_f64*)<br/> [vrndiq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndiq_f32*)<br/> [vrndiq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndiq_f64*)<br/></details>|
+|vrndm|Round to Integral, towards minus infinity|<details><summary>Click here to expand the API list</summary>[vrndm_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndm_f32*)<br/> [vrndm_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndm_f64*)<br/> [vrndmq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndmq_f32*)<br/> [vrndmq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndmq_f64*)<br/></details>|
+|vrndn|Round to Integral, with ties to even|<details><summary>Click here to expand the API list</summary>[vrndn_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndn_f32*)<br/> [vrndn_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndn_f64*)<br/> [vrndnq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndnq_f32*)<br/> [vrndnq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndnq_f64*)<br/> [vrndns_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndns_f32*)<br/></details>|
+|vrndp|Round to Integral, towards plus infinity|<details><summary>Click here to expand the API list</summary>[vrndp_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndp_f32*)<br/> [vrndp_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndp_f64*)<br/> [vrndpq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndpq_f32*)<br/> [vrndpq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndpq_f64*)<br/></details>|
+|vrndx|Round to Integral exact|<details><summary>Click here to expand the API list</summary>[vrndx_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndx_f32*)<br/> [vrndx_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndx_f64*)<br/> [vrndxq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndxq_f32*)<br/> [vrndxq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vrndxq_f64*)<br/></details>|
+
+
+### Load and store
+
+|Operation|Description|APIs|
+|---|---|---|
+|vld1|Load vector from memory|<details><summary>Click here to expand the API list</summary>[vld1_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_f32*)<br/>[vld1_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_f64*)<br/>[vld1_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_s16*)<br/>[vld1_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_s32*)<br/>[vld1_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_s64*)<br/>[vld1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_s8*)<br/>[vld1_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_u16*)<br/>[vld1_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_u32*)<br/>[vld1_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_u64*)<br/>[vld1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1_u8*)<br/>[vld1q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_f32*)<br/>[vld1q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_f64*)<br/>[vld1q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_s16*)<br/>[vld1q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_s32*)<br/>[vld1q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_s64*)<br/>[vld1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_s8*)<br/>[vld1q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_u16*)<br/>[vld1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_u32*)<br/>[vld1q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_u64*)<br/>[vld1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vld1q_u8*)<br/></details>|
+|vst1|Store vector to memory|<details><summary>Click here to expand the API list</summary>[vst1_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_f32*)<br/>[vst1_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_f64*)<br/>[vst1_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_s16*)<br/>[vst1_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_s32*)<br/>[vst1_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_s64*)<br/>[vst1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_s8*)<br/>[vst1_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_u16*)<br/>[vst1_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_u32*)<br/>[vst1_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_u64*)<br/>[vst1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1_u8*)<br/>[vst1q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_f32*)<br/>[vst1q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_f64*)<br/>[vst1q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_s16*)<br/>[vst1q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_s32*)<br/>[vst1q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_s64*)<br/>[vst1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_s8*)<br/>[vst1q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_u16*)<br/>[vst1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_u32*)<br/>[vst1q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_u64*)<br/>[vst1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vst1q_u8*)<br/></details>|
+|vget_lane|Get vector element|<details><summary>Click here to expand the API list</summary>[vget_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_f32*)<br/>[vget_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_f64*)<br/>[vget_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_s16*)<br/>[vget_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_s32*)<br/>[vget_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_s64*)<br/>[vget_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_s8*)<br/>[vget_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_u16*)<br/>[vget_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_u32*)<br/>[vget_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_u64*)<br/>[vget_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vget_lane_u8*)<br/>[vgetq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_f32*)<br/>[vgetq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_f64*)<br/>[vgetq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_s16*)<br/>[vgetq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_s32*)<br/>[vgetq_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_s64*)<br/>[vgetq_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_s8*)<br/>[vgetq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_u16*)<br/>[vgetq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_u32*)<br/>[vgetq_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_u64*)<br/>[vgetq_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vgetq_lane_u8*)<br/></details>|
+|vset_lane|Set vector element|<details><summary>Click here to expand the API list</summary>[vset_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_f32*)<br/>[vset_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_f64*)<br/>[vset_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_s16*)<br/>[vset_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_s32*)<br/>[vset_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_s64*)<br/>[vset_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_s8*)<br/>[vset_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_u16*)<br/>[vset_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_u32*)<br/>[vset_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_u64*)<br/>[vset_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vset_lane_u8*)<br/>[vsetq_lane_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_f32*)<br/>[vsetq_lane_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_f64*)<br/>[vsetq_lane_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_s16*)<br/>[vsetq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_s32*)<br/>[vsetq_lane_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_s64*)<br/>[vsetq_lane_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_s8*)<br/>[vsetq_lane_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_u16*)<br/>[vsetq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_u32*)<br/>[vsetq_lane_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_u64*)<br/>[vsetq_lane_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vsetq_lane_u8*)<br/></details>|
+
+### Permutation
+
+|Operation|Description|APIs|
+|---|---|---|
+|vext|Extract vector from pair of vectors|<details><summary>Click here to expand the API list</summary>[vext_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_f32*)<br/>[vext_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_f64*)<br/>[vext_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_s16*)<br/>[vext_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_s32*)<br/>[vext_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_s64*)<br/>[vext_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_s8*)<br/>[vext_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_u16*)<br/>[vext_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_u32*)<br/>[vext_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_u64*)<br/>[vext_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vext_u8*)<br/>[vextq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_f32*)<br/>[vextq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_f64*)<br/>[vextq_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_s16*)<br/>[vextq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_s32*)<br/>[vextq_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_s64*)<br/>[vextq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_s8*)<br/>[vextq_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_u16*)<br/>[vextq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_u32*)<br/>[vextq_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_u64*)<br/>[vextq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vextq_u8*)<br/></details>|
+|vtbl1|Table vector Lookup|<details><summary>Click here to expand the API list</summary>[vtbl1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtbl1_s8*)<br/>[vtbl1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtbl1_u8*)<br/></details>|
+|vtbx1|Table vector lookup extension|<details><summary>Click here to expand the API list</summary>[vtbx1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtbx1_s8*)<br/>[vtbx1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtbx1_u8*)<br/></details>|
+|vqtbl1|Table vector Lookup|<details><summary>Click here to expand the API list</summary>[vqtbl1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbl1_s8*)<br/> [vqtbl1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbl1_u8*)<br/> [vqtbl1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbl1q_s8*)<br/> [vqtbl1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbl1q_u8*)<br/></details>|
+|vqtbx1|Table vector lookup extension|<details><summary>Click here to expand the API list</summary>[vqtbx1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbx1_s8*)<br/> [vqtbx1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbx1_u8*)<br/> [vqtbx1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbx1q_s8*)<br/> [vqtbx1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vqtbx1q_u8*)<br/></details>|
+|vrbit|Reverse bit order|<details><summary>Click here to expand the API list</summary>[vrbit_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrbit_s8*)<br/> [vrbit_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrbit_u8*)<br/> [vrbitq_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrbitq_s8*)<br/> [vrbitq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrbitq_u8*)<br/></details>|
+|vrev16|Reverse elements in 16-bit halfwords|<details><summary>Click here to expand the API list</summary>[vrev16_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev16_s8*)<br/>[vrev16_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev16_u8*)<br/>[vrev16q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev16q_s8*)<br/>[vrev16q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev16q_u8*)<br/></details>|
+|vrev32|Reverse elements in 32-bit words|<details><summary>Click here to expand the API list</summary>[vrev32_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32_s16*)<br/>[vrev32_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32_s8*)<br/>[vrev32_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32_u16*)<br/>[vrev32_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32_u8*)<br/>[vrev32q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32q_s16*)<br/>[vrev32q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32q_s8*)<br/>[vrev32q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32q_u16*)<br/>[vrev32q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev32q_u8*)<br/></details>|
+|vrev64|Reverse elements in 64-bit doublewords|<details><summary>Click here to expand the API list</summary>[vrev64_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_f32*)<br/>[vrev64_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_s16*)<br/>[vrev64_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_s32*)<br/>[vrev64_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_s8*)<br/>[vrev64_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_u16*)<br/>[vrev64_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_u32*)<br/>[vrev64_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64_u8*)<br/>[vrev64q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_f32*)<br/>[vrev64q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_s16*)<br/>[vrev64q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_s32*)<br/>[vrev64q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_s8*)<br/>[vrev64q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_u16*)<br/>[vrev64q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_u32*)<br/>[vrev64q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vrev64q_u8*)<br/></details>|
+|vtrn1|Transpose vectors (primary)|<details><summary>Click here to expand the API list</summary>[vtrn1_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_f32*)<br/>[vtrn1_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_s16*)<br/>[vtrn1_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_s32*)<br/>[vtrn1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_s8*)<br/>[vtrn1_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_u16*)<br/>[vtrn1_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_u32*)<br/>[vtrn1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1_u8*)<br/>[vtrn1q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_f32*)<br/>[vtrn1q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_f64*)<br/>[vtrn1q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_s16*)<br/>[vtrn1q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_s32*)<br/>[vtrn1q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_s64*)<br/>[vtrn1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_s8*)<br/>[vtrn1q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_u16*)<br/>[vtrn1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_u32*)<br/>[vtrn1q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_u64*)<br/>[vtrn1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn1q_u8*)<br/></details>|
+|vtrn2|Transpose vectors (secondary)|<details><summary>Click here to expand the API list</summary>[vtrn2_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_f32*)<br/>[vtrn2_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_s16*)<br/>[vtrn2_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_s32*)<br/>[vtrn2_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_s8*)<br/>[vtrn2_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_u16*)<br/>[vtrn2_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_u32*)<br/>[vtrn2_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2_u8*)<br/>[vtrn2q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_f32*)<br/>[vtrn2q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_f64*)<br/>[vtrn2q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_s16*)<br/>[vtrn2q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_s32*)<br/>[vtrn2q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_s64*)<br/>[vtrn2q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_s8*)<br/>[vtrn2q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_u16*)<br/>[vtrn2q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_u32*)<br/>[vtrn2q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_u64*)<br/>[vtrn2q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vtrn2q_u8*)<br/></details>|
+|vzip1|Zip vectors (primary)|<details><summary>Click here to expand the API list</summary>[vzip1_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_f32*)<br/>[vzip1_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_s16*)<br/>[vzip1_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_s32*)<br/>[vzip1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_s8*)<br/>[vzip1_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_u16*)<br/>[vzip1_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_u32*)<br/>[vzip1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1_u8*)<br/>[vzip1q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_f32*)<br/>[vzip1q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_f64*)<br/>[vzip1q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_s16*)<br/>[vzip1q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_s32*)<br/>[vzip1q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_s64*)<br/>[vzip1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_s8*)<br/>[vzip1q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_u16*)<br/>[vzip1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_u32*)<br/>[vzip1q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_u64*)<br/>[vzip1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip1q_u8*)<br/></details>|
+|vzip2|Zip vectors (secondary)|<details><summary>Click here to expand the API list</summary>[vzip2_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_f32*)<br/>[vzip2_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_s16*)<br/>[vzip2_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_s32*)<br/>[vzip2_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_s8*)<br/>[vzip2_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_u16*)<br/>[vzip2_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_u32*)<br/>[vzip2_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2_u8*)<br/[vzip2q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_f32*)<br/>[vzip2q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_f64*)<br/>[vzip2q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_s16*)<br/>[vzip2q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_s32*)<br/>[vzip2q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_s64*)<br/>[vzip2q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_s8*)<br/>[vzip2q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_u16*)<br/>[vzip2q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_u32*)<br/>[vzip2q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_u64*)<br/>[vzip2q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vzip2q_u8*)<br/></details>|
+|vuzp1|Unzip vectors (primary)|<details><summary>Click here to expand the API list</summary>[vuzp1_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_f32*)<br/>[vuzp1_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_s16*)<br/>[vuzp1_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_s32*)<br/>[vuzp1_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_s8*)<br/>[vuzp1_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_u16*)<br/>[vuzp1_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_u32*)<br/>[vuzp1_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1_u8*)<br/>[vuzp1q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_f32*)<br/>[vuzp1q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_f64*)<br/>[vuzp1q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_s16*)<br/>[vuzp1q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_s32*)<br/>[vuzp1q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_s64*)<br/>[vuzp1q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_s8*)<br/>[vuzp1q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_u16*)<br/>[vuzp1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_u32*)<br/>[vuzp1q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_u64*)<br/>[vuzp1q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp1q_u8*)<br/></details>|
+|vuzp2|Unzip vectors (secondary)|<details><summary>Click here to expand the API list</summary>[vuzp2_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_f32*)<br/>[vuzp2_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_s16*)<br/>[vuzp2_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_s32*)<br/>[vuzp2_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_s8*)<br/>[vuzp2_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_u16*)<br/>[vuzp2_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_u32*)<br/>[vuzp2_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2_u8*)<br/>[vuzp2q_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_f32*)<br/>[vuzp2q_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_f64*)<br/>[vuzp2q_s16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_s16*)<br/>[vuzp2q_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_s32*)<br/>[vuzp2q_s64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_s64*)<br/>[vuzp2q_s8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_s8*)<br/>[vuzp2q_u16](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_u16*)<br/>[vuzp2q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_u32*)<br/>[vuzp2q_u64](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_u64*)<br/>[vuzp2q_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vuzp2q_u8*)<br/></details>|
+
+### Cryptographic
+
+|Operation|APIs|
+|---|---|
+|CRC32|<details><summary>Click here to expand the API list</summary>[__crc32b](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32b*)<br/>[__crc32cb](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32cb*)<br/>[__crc32cd](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32cd*)<br/>[__crc32ch](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32ch*)<br/>[__crc32cw](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32cw*)<br/>[__crc32d](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32d*)<br/>[__crc32h](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32h*)<br/>[__crc32w](xref:Unity.Burst.Intrinsics.Arm.Neon.__crc32w*)<br/></details>|
+|SHA1|<details><summary>Click here to expand the API list</summary>[vsha1cq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha1cq_u32*)<br/>[vsha1h_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha1h_u32*)<br/>[vsha1mq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha1mq_u32*)<br/>[vsha1pq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha1pq_u32*)<br/>[vsha1su0q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha1su0q_u32*)<br/>[vsha1su1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha1su1q_u32*)<br/></details>|
+|SHA256|<details><summary>Click here to expand the API list</summary>[vsha256h2q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha256h2q_u32*)<br/>[vsha256hq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha256hq_u32*)<br/>[vsha256su0q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha256su0q_u32*)<br/>[vsha256su1q_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsha256su1q_u32*)<br/></details>|
+|AES|<details><summary>Click here to expand the API list</summary>[vaesdq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaesdq_u8*)<br/>[vaeseq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaeseq_u8*)<br/>[vaesimcq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaesimcq_u8*)<br/>[vaesmcq_u8](xref:Unity.Burst.Intrinsics.Arm.Neon.vaesmcq_u8*)<br/></details>|
+
+### Miscellaneous
+
+|Operation|Description|APIs|
+|---|---|---|
+|vsqrt|Square root|<details><summary>Click here to expand the API list</summary>[vsqrt_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqrt_f32*)<br/> [vsqrt_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqrt_f64*)<br/> [vsqrtq_f32](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqrtq_f32*)<br/> [vsqrtq_f64](xref:Unity.Burst.Intrinsics.Arm.Neon.vsqrtq_f64*)<br/></details>|
+|vdot|Dot product|<details><summary>Click here to expand the API list</summary>[vdot_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdot_s32*)<br/> [vdot_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdot_u32*)<br/> [vdotq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdotq_s32*)<br/> [vdotq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdotq_u32*)<br/></details>|
+|vdot_lane|Dot product|<details><summary>Click here to expand the API list</summary>[vdot_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdot_lane_s32*)<br/> [vdot_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdot_lane_u32*)<br/> [vdot_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdot_laneq_s32*)<br/> [vdot_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdot_laneq_u32*)<br/> [vdotq_lane_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdotq_lane_s32*)<br/> [vdotq_lane_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdotq_lane_u32*)<br/> [vdotq_laneq_s32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdotq_laneq_s32*)<br/> [vdotq_laneq_u32](xref:Unity.Burst.Intrinsics.Arm.Neon.vdotq_laneq_u32*)<br/></details>|

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-burst-intrinsics-processors.md

@@ -0,0 +1,113 @@
+# Processor specific SIMD extensions
+
+Burst exposes all Intel SIMD intrinsics from SSE up to and including AVX2 in the [`Unity.Burst.Intrinsics.X86`](xref:Unity.Burst.Intrinsics.X86) family of nested classes. The [`Unity.Burst.Intrinsics.Arm.Neon`](xref:Unity.Burst.Intrinsics.Arm.Neon) class provides intrinsics for Arm Neon's Armv7, Armv8, and Armv8.2 (RDMA, crypto, dotprod).
+
+## Organizing your code
+
+You should statically import these intrinsics because they contain plain static functions:
+
+```c#
+using static Unity.Burst.Intrinsics.X86;
+using static Unity.Burst.Intrinsics.X86.Sse;
+using static Unity.Burst.Intrinsics.X86.Sse2;
+using static Unity.Burst.Intrinsics.X86.Sse3;
+using static Unity.Burst.Intrinsics.X86.Ssse3;
+using static Unity.Burst.Intrinsics.X86.Sse4_1;
+using static Unity.Burst.Intrinsics.X86.Sse4_2;
+using static Unity.Burst.Intrinsics.X86.Popcnt;
+using static Unity.Burst.Intrinsics.X86.Avx;
+using static Unity.Burst.Intrinsics.X86.Avx2;
+using static Unity.Burst.Intrinsics.X86.Fma;
+using static Unity.Burst.Intrinsics.X86.F16C;
+using static Unity.Burst.Intrinsics.X86.Bmi1;
+using static Unity.Burst.Intrinsics.X86.Bmi2;
+using static Unity.Burst.Intrinsics.Arm.Neon;
+```
+
+Burst CPU intrinsics are translated into specific CPU instructions. However, Burst has a special compiler pass which makes sure that your CPU target set in `Burst AOT Settings` is compatible with the intrinsics used in your code. This ensures you don't try to call unsupported instructions (for example, AArch64 Neon on an Intel CPU or AVX2 instructions on an SSE4 CPU), which causes the process to abort with an "Invalid instruction" exception. A compiler error is generated if the check fails.
+
+However, if you want to provide several code paths with different CPU targets, or to make sure your intrinsics code is compatible with any target CPU, you can wrap your intrinsics code with the followinf property checks:
+
+* [IsNeonSupported](xref:Unity.Burst.Intrinsics.Arm.Neon.IsNeonSupported)
+* [IsNeonArmv82FeaturesSupported](xref:Unity.Burst.Intrinsics.Arm.Neon.IsNeonArmv82FeaturesSupported)
+* [IsNeonCryptoSupported](xref:Unity.Burst.Intrinsics.Arm.Neon.IsNeonCryptoSupported)
+* [IsNeonDotProdSupported](xref:Unity.Burst.Intrinsics.Arm.Neon.IsNeonDotProdSupported)
+* [IsNeonRDMASupported](xref:Unity.Burst.Intrinsics.Arm.Neon.IsNeonRDMASupported)
+
+For example:
+
+```c#
+if (IsAvx2Supported)
+{
+    // Code path for AVX2 instructions
+}
+else if (IsSse42Supported)
+{
+    // Code path for SSE4.2 instructions
+}
+else if (IsNeonArmv82FeaturesSupported)
+{
+    // Code path for Armv8.2 Neon instructions
+}
+else if (IsNeonSupported)
+{
+    // Code path for Arm Neon instructions
+}
+else
+{
+    // Fallback path for everything else
+}
+```
+
+These branches don't affect performance. Burst evaluates the `IsXXXSupported` properties at compile-time and eliminates unsupported branches as dead code, while the active branch stays there without the if check. Later feature levels implicitly include the previous ones, so you should organize tests from most recent to oldest. Burst emits compile-time errors if you've used intrinsics that aren't part of the current compilation target. Burst doesn't bracket these with a feature level test, which helps you to narrow in on what to put inside a feature test.
+
+If you run your application in .NET, Mono or IL2CPP without Burst enabled, all the `IsXXXSupported` properties return `false`. However, if you skip the test you can still run a reference version of most intrinsics in Mono (exceptions listed below), which is helpful if you need to use the managed debugger. Reference implementations are slow and only intended for managed debugging.
+
+>[!IMPORTANT]
+>There isn't a reference managed implementation of Arm Neon intrinsics. This means that you can't use the technique mentioned in the previous paragraph to step through the intrinsics in Mono. FMA intrinsics that operate on doubles don't have a software fallback because of the inherit complexity in emulating fused 64-bit floating point math.
+
+
+
+
+
+
+Intrinsics use the types `v64` (Arm only), `v128` and `v256`, which represent a 64-bit, 128-bit or 256-bit vector respectively. For example, given a `NativeArray<float>` and a `Lut` lookup table of v128 shuffle masks, a code fragment like this performs lane left packing, demonstrating the use of vector load/store reinterpretation and direct intrinsic calls:
+
+```c#
+v128 a = Input.ReinterpretLoad<v128>(i);
+v128 mask = cmplt_ps(a, Limit);
+int m = movemask_ps(a);
+v128 packed = shuffle_epi8(a, Lut[m]);
+Output.ReinterpretStore(outputIndex, packed);
+outputIndex += popcnt_u32((uint)m);
+```
+
+## Intel intrinsics
+
+The Intel intrinsics API mirrors the [C/C++ Intel instrinsics API](https://software.intel.com/sites/landingpage/IntrinsicsGuide/), with a the following differences:
+
+* All 128-bit vector types (`__m128`, `__m128i` and `__m128d`) are collapsed into `v128`
+* All 256-bit vector types (`__m256`, `__m256i` and `__m256d`) are collapsed into `v256`
+* All `_mm` prefixes on instructions and macros are dropped, because C# has namespaces
+* All bitfield constants (for example, rounding mode selection) are replaced with C# bitflag enum values
+
+## Arm Neon intrinsics
+
+The Arm Neon intrinsics API mirrors the [Arm C Language Extensions](https://developer.arm.com/architectures/instruction-sets/simd-isas/neon/intrinsics), with the following differences:
+
+* All vector types are collapsed into `v64` and `v128`, becoming typeless. This means that the vector type must contain expected element types and count when calling an API.
+* The `*x2`, `*x3`, `*x4` vector types aren't supported.
+* `poly*` types aren't supported.
+* `reinterpret*` functions aren't supported (they aren't needed because of the usage of `v64` and `v128` vector types).
+* Intrinsic usage is only supported on Armv8 (64-bit) hardware.
+
+Burst's CPU intrinsics use typeless vectors. Because of this, Burst doesn't perform any type checks. For example, if you call an intrinsic which processes 4 ints on a vector that was initialized with 4 floats, then there's no compiler error. The vector types have fields that represent every element type, in a union-like struct, which gives you flexibility to use these intrinsics in a way that best fits your code.
+
+Arm Neon C intrinsics (ACLE) use typed vectors, for example int32x4_t, and has special APIs (for example, `reinterpret_\*`) to convert to a vector of another element type. Burst CPU intrinsics vectors are typeless, so these APIs are not needed. The following APIs provide the equivalent functionality:
+
+* [v64 (Arm Neon only)](xref:Unity.Burst.Intrinsics.v64)
+* [v128](xref:Unity.Burst.Intrinsics.v128)
+* [v256](xref:Unity.Burst.Intrinsics.v256)
+	
+
+For a categorized index of Arm Neon intrinsics supported in Burst, see the [Arm Neon intrinsics reference](csharp-burst-intrinsics-neon.md).

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-burst-intrinsics.md

@@ -0,0 +1,12 @@
+# Burst intrinsics overview
+
+Burst provides low level intrinsics in the [`Unity.Burst.Intrinsics`](xref:Unity.Burst.Intrinsics) namespace. This is useful if you know how to write single instruction, multiple data (SIMD) assembly code, and you want to get extra performance from Burst code. For most use cases, you won't need to use these.
+
+This section contains the following information
+
+|**Page**|**Description**|
+|---|---|
+|[Burst intrinsics Common class](csharp-burst-intrinsics-common.md)|Overview of the `Burst.Intrinsics.Common` class, which provides functionality shared across the hardware targets that Burst supports. |
+|[DllImport and internal calls](csharp-burst-intrinsics-dllimport.md)|Overview of `[DllImport]`, which is for calling native functions.|
+|[Processor specific SIMD extensions](csharp-burst-intrinsics-processors.md)|Overview of the Intel and Arm Neon intrinsics.|
+|[Arm Neon intrinsics reference](csharp-burst-intrinsics-neon.md)|Reference of the methods in the `Burst.Intrinsics.Arm.Neon` class.|

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-calling-burst-code.md

@@ -0,0 +1,52 @@
+# Calling Burst-compiled code
+
+You can call Burst-compiled methods direct from managed code. Calling generic methods or methods whose declaring type is generic isn't supported, otherwise the rules as for [function pointers](csharp-function-pointers.md) apply. However, you don't need to worry about the extra boiler plate needed for function pointers.
+
+The following example shows a Burst-compiled utility class. Because it uses structs, it passes by reference per the [function pointer](csharp-function-pointers.md) rules.
+
+```c#
+[BurstCompile]
+public static class MyBurstUtilityClass
+{
+    [BurstCompile]
+    public static void BurstCompiled_MultiplyAdd(in float4 mula, in float4 mulb, in float4 add, out float4 result)
+    {
+        result = mula * mulb + add;
+    }
+}
+```
+Use this method from managed code like so:
+
+```c#
+public class MyMonoBehaviour : MonoBehaviour
+{
+    void Start()
+    {
+        var mula = new float4(1, 2, 3, 4);
+        var mulb = new float4(-1,1,-1,1);
+        var add = new float4(99,0,0,0);
+        MyBurstUtilityClass.BurstCompiled_MultiplyAdd(mula, mulb, add, out var result);
+        Debug.Log(result);
+    }
+}
+```
+
+If you attach this script to an object and run it, `float4(98f, 2f, -3f, 4f)` is printed to the log. 
+
+## Code transformation
+
+Burst uses IL Post Processing to automatically transform the code into a function pointer and call. For more information, see the documentation on [Function pointers](csharp-function-pointers.md).
+
+To disable the direct call transformation, add`DisableDirectCall = true` to the BurstCompile options. This prevents the Post Processor from running on the code:
+
+```c#
+[BurstCompile]
+public static class MyBurstUtilityClass
+{
+    [BurstCompile(DisableDirectCall = true)]
+    public static void BurstCompiled_MultiplyAdd(in float4 mula, in float4 mulb, in float4 add, out float4 result)
+    {
+        result = mula * mulb + add;
+    }
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-function-pointers.md

@@ -0,0 +1,179 @@
+# Function pointers
+
+To work with dynamic functions that process data based on other data states, use [`FunctionPointer<T>`](xref:Unity.Burst.FunctionPointer`1). Because Burst treats delegates as managed objects, you can't use [C# delegates](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/) to work with dynamic functions.
+
+## Support details
+
+Function pointers don't support generic delegates. Also, avoid wrapping [`BurstCompiler.CompileFunctionPointer<T>`](xref:Unity.Burst.BurstCompiler.CompileFunctionPointer``1(``0)) within another open generic method. If you do this, Burst can't apply required attributes to the delegate, perform additional safety analysis, or perform potential optimizations. 
+
+Argument and return types are subject to the same restrictions as `DllImport` and internal calls. For more information, see the documentation on [DllImport and internal calls](csharp-burst-intrinsics-dllimport.md).
+
+### Interoperability with IL2CPP
+
+Interoperability of function pointers with IL2CPP requires `System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute` on the delegate. Set the calling convention to `CallingConvention.Cdecl`. Burst automatically adds this attribute to delegates that are used with [`BurstCompiler.CompileFunctionPointer<T>`](xref:Unity.Burst.BurstCompiler.CompileFunctionPointer``1(``0)).
+
+## Using function pointers
+
+To use function pointers, identify the static functions that you want Burst to compile and do the following:
+
+1. Add a `[BurstCompile]` attribute to these functions
+1. Add a `[BurstCompile]` attribute to the containing type. This helps the Burst compiler find the static methods that have `[BurstCompile]` attribute
+1. Declare a delegate to create the "interface" of these functions
+1. Add a `[MonoPInvokeCallbackAttribute]` attribute to the functions. You need to add this so that IL2CPP works with these functions. For example:
+
+    ```c#
+    // Instruct Burst to look for static methods with [BurstCompile] attribute
+    [BurstCompile]
+    class EnclosingType {
+        [BurstCompile]
+        [MonoPInvokeCallback(typeof(Process2FloatsDelegate))]
+        public static float MultiplyFloat(float a, float b) => a * b;
+    
+        [BurstCompile]
+        [MonoPInvokeCallback(typeof(Process2FloatsDelegate))]
+        public static float AddFloat(float a, float b) => a + b;
+    
+        // A common interface for both MultiplyFloat and AddFloat methods
+        public delegate float Process2FloatsDelegate(float a, float b);
+    }
+    ```
+
+1. Compile these function pointers from regular C# code:
+
+    ```c#
+        // Contains a compiled version of MultiplyFloat with Burst
+        FunctionPointer<Process2FloatsDelegate> mulFunctionPointer = BurstCompiler.CompileFunctionPointer<Process2FloatsDelegate>(MultiplyFloat);
+    
+        // Contains a compiled version of AddFloat with Burst
+        FunctionPointer<Process2FloatsDelegate> addFunctionPointer = BurstCompiler.    CompileFunctionPointer<Process2FloatsDelegate>(AddFloat);
+    ```
+
+### Using function pointers in a job
+
+To use the function pointers directly from a job, pass them to the job struct:
+
+```c#
+    // Invoke the function pointers from HPC# jobs
+    var resultMul = mulFunctionPointer.Invoke(1.0f, 2.0f);
+    var resultAdd = addFunctionPointer.Invoke(1.0f, 2.0f);
+``` 
+
+Burst compiles function pointers asynchronously for jobs by default. To force a synchronous compilation of function pointers use `[BurstCompile(SynchronousCompilation = true)]`.
+
+### Using function pointers in C# code
+
+To use these function pointers from regular C# code, cache the `FunctionPointer<T>.Invoke` property (which is the delegate instance) to a static field to get the best performance:
+
+```c#
+    private readonly static Process2FloatsDelegate mulFunctionPointerInvoke = BurstCompiler.CompileFunctionPointer<Process2FloatsDelegate>(MultiplyFloat).Invoke;
+
+    // Invoke the delegate from C#
+    var resultMul = mulFunctionPointerInvoke(1.0f, 2.0f);
+```
+
+Using Burst-compiled function pointers from C# might be slower than their pure C# version counterparts if the function is too small compared to the overhead of [`P/Invoke`](https://docs.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke) interop.
+
+
+## Performance considerations
+
+Where possible, you use a job over a function pointer to run Burst compiled code, because jobs are more optimal. Burst provides better aliasing calculations for jobs because the job safety system has more optimizations by default.
+
+You also can't pass most of the `[NativeContainer]` structs like `NativeArray` directly to function pointers and must use a job struct to do so. Native container structs contain managed objects for safety checks that the Burst compiler can work around when compiling jobs, but not for function pointers.
+
+The following example shows a bad example of how to use function pointers in Burst. The function pointer computes `math.sqrt` from an input pointer and stores it to an output pointer. `MyJob` feeds this function pointer sources from two `NativeArray`s which isn't optimal:
+
+```c#
+///Bad function pointer example
+[BurstCompile]
+public class MyFunctionPointers
+{
+    public unsafe delegate void MyFunctionPointerDelegate(float* input, float* output);
+
+    [BurstCompile]
+    public static unsafe void MyFunctionPointer(float* input, float* output)
+    {
+        *output = math.sqrt(*input);
+    }
+}
+
+[BurstCompile]
+struct MyJob : IJobParallelFor
+{
+     public FunctionPointer<MyFunctionPointers.MyFunctionPointerDelegate> FunctionPointer;
+
+    [ReadOnly] public NativeArray<float> Input;
+    [WriteOnly] public NativeArray<float> Output;
+
+    public unsafe void Execute(int index)
+    {
+        var inputPtr = (float*)Input.GetUnsafeReadOnlyPtr();
+        var outputPtr = (float*)Output.GetUnsafePtr();
+        FunctionPointer.Invoke(inputPtr + index, outputPtr + index);
+    }
+}
+```
+
+This example isn't optimal for the following reasons:
+
+* Burst can't vectorize the function pointer because it's being fed a single scalar element. This means that 4-8x performance is lost from a lack of vectorization.
+* The `MyJob` knows that the `Input` and `Output` native arrays can't alias, but this information isn't communicated to the function pointer.
+* There is a non-zero overhead to constantly branching to a function pointer somewhere else in memory.
+
+To use a function pointer in an optimal way, always process batches of data in the function pointer, like so:
+
+```c#
+[BurstCompile]
+public class MyFunctionPointers
+{
+    public unsafe delegate void MyFunctionPointerDelegate(int count, float* input, float* output);
+
+    [BurstCompile]
+    public static unsafe void MyFunctionPointer(int count, float* input, float* output)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            output[i] = math.sqrt(input[i]);
+        }
+    }
+}
+
+[BurstCompile]
+struct MyJob : IJobParallelForBatch
+{
+     public FunctionPointer<MyFunctionPointers.MyFunctionPointerDelegate> FunctionPointer;
+
+    [ReadOnly] public NativeArray<float> Input;
+    [WriteOnly] public NativeArray<float> Output;
+
+    public unsafe void Execute(int index, int count)
+    {
+        var inputPtr = (float*)Input.GetUnsafeReadOnlyPtr() + index;
+        var outputPtr = (float*)Output.GetUnsafePtr() + index;
+        FunctionPointer.Invoke(count, inputPtr, outputPtr);
+    }
+}
+```
+
+Thee modified `MyFunctionPointer` takes a `count` of elements to process, and loops over the `input` and `output` pointers to do a lot of calculations. The `MyJob` becomes an `IJobParallelForBatch`, and the `count` is passed directly into the function pointer. This is better for performance because of the following reasons:
+
+* Burst vectorizes the `MyFunctionPointer` call.
+* Because Burst processes `count` items per function pointer, any overhead of calling the function pointer is reduced by `count` times. For example, if you run a batch of 128, the function pointer overhead is 1/128th per `index` of what it was previously.
+* Batching results in a 1.53x performance gain over not batching.
+
+However, to get the best possible performance, use a job. This gives Burst the most visibility over what you want it to do, and the most opportunities to optimize:
+
+```c#
+[BurstCompile]
+struct MyJob : IJobParallelFor
+{
+    [ReadOnly] public NativeArray<float> Input;
+    [WriteOnly] public NativeArray<float> Output;
+
+    public unsafe void Execute(int index)
+    {
+        Output[i] = math.sqrt(Input[i]);
+    }
+}
+```
+
+This runs 1.26x faster than the batched function pointer example, and 1.93x faster than the non-batched function pointer examples. Burst has perfect aliasing knowledge and can make the broadest modifications to the above. This code is also a lot simpler than either of the function pointer cases.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-hpc-overview.md

@@ -0,0 +1,42 @@
+## HPC# overview
+
+Burst uses a high performance subset of C# called High Performance C# (HPC#).
+
+## Supported C# features in HPC#
+
+HPC# supports most expressions and statements in C#. It supports the following:
+
+|**Supported feature**|**Notes**|
+|---|---|
+|Extension methods.||
+|Instance methods of structs.||
+|Unsafe code and pointer manipulation.||
+|Loading from static read-only fields.|For more information, see the documentation on [Static read-only fields and static constructors](csharp-static-read-only-support.md).|
+|Regular C# control flows.|`if`<br/>`else`<br/>`switch`<br/>`case`<br/>`for`<br/>`while`<br/>`break`<br/>`continue`|
+|`ref` and `out` parameters||
+|`fixed` statements||
+|Some [IL opcodes](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes?view=net-6.0).|`cpblk`<br/> `initblk`<br/> `sizeof`|
+|`DLLImport` and internal calls.|For more information, see the documentation on [`DLLImport` and internal calls](csharp-burst-intrinsics-dllimport.md).|
+|`try` and `finally` keywords. Burst also supports the associated [IDisposable](https://docs.microsoft.com/en-us/dotnet/api/system.idisposable?view=net-6.0) patterns, `using` and `foreach`.|If an exception happens in Burst, the behavior is different from .NET. In .NET, if an exception occurs inside a `try` block, control flow goes to the `finally` block. However, in Burst, if an exception happens inside or outside a `try` block, the exception throws as if any `finally` blocks do not exist.|
+|Strings and `ProfilerMarker`.|For more information, see the documentation on [Support for Unity Profiler markers](debugging-profiling-tools.md#profiler-markers).|
+|`throw` expressions.| Burst only supports simple `throw` patterns, for example, `throw new ArgumentException("Invalid argument")`. When you use simple patterns like this, Burst extracts the static string exception message and includes it in the generated code.|
+|Strings and `Debug.Log`.|Only partially supported. For more information, see the documentation on [String support and `Debug.Log`](csharp-string-support.md). |
+
+Burst also provides alternatives for some C# constructions not directly accessible to HPC#:
+
+* [Function pointers](csharp-function-pointers.md) as an alternative to using delegates within HPC#
+* [Shared static](csharp-shared-static.md) to access static mutable data from both C# and HPC#
+
+### Exception expressions
+
+Burst supports `throw` expressions for exceptions. Exceptions thrown in the **editor** can be caught by managed code, and are reported in the console window. Exceptions thrown in **player builds** will always cause the application to abort. Thus with Burst you should only use exceptions for exceptional behavior. To ensure that code doesn't end up relying on exceptions for things like general control flow, Burst produces the following warning on code that tries to `throw` within a method not attributed with `[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]`:
+
+> Burst warning BC1370: An exception was thrown from a function without the correct [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] guard. Exceptions only work in the editor and so should be protected by this guard
+
+## Unsupported C# features in HPC#
+
+HPC# doesn't support the following C# features:
+
+* Catching exceptions `catch` in a `try`/`catch`.
+* Storing to static fields except via [Shared Static](csharp-shared-static.md)
+* Any methods related to managed objects, for example, string methods.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-language-support.md

@@ -0,0 +1,18 @@
+# C# language support
+
+Burst uses a high performance subset of C# called High Performance C# (HPC#) which has a number of limitations and differences between C#.
+
+|**Topic**|**Description**|
+|---|---|
+|[HPC# overview](csharp-hpc-overview.md)|Understand how HPC# works with Burst.|
+|[C#/.NET type support](csharp-type-support.md)| Understand the supported C# features.|
+|[C#/.NET System namespace support](csharp-system-support.md)| Understand what's supported in the System namespace.|
+|[Static read-only fields and static constructor support](csharp-static-read-only-support.md)|Use static read-only fields and static constructors in Burst code.|
+|[String support](csharp-string-support.md)|Use strings in Burst code.|
+|[Calling Burst compiled code](csharp-calling-burst-code.md)| Call Burst compiled code from managed code.|
+[Function pointers](csharp-function-pointers.md)|Use function pointers to work with dynamic functions.|
+|[SharedStatic struct](csharp-shared-static.md)| Use SharedStatic to share static mutable data.|
+
+## Additional resources
+
+* [Burst instrinsics overview](csharp-burst-intrinsics.md)

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-shared-static.md

@@ -0,0 +1,30 @@
+# SharedStatic struct
+
+Burst has basic support for accessing static readonly data. However, if you want to share static mutable data between C# and HPC#, use the `SharedStatic<T>` struct.
+
+The following example shows accessing an `int` static field that both C# and HPC# can change: 
+
+```C#
+    public abstract class MutableStaticTest
+    {
+        public static readonly SharedStatic<int> IntField = SharedStatic<int>.GetOrCreate<MutableStaticTest, IntFieldKey>();
+
+        // Define a Key type to identify IntField
+        private class IntFieldKey {}
+    }
+```     
+
+C# and HPC# can then access this:
+
+```C#
+    // Write to a shared static 
+    MutableStaticTest.IntField.Data = 5;
+    // Read from a shared static
+    var value = 1 + MutableStaticTest.IntField.Data;
+``` 
+
+When you use `SharedStatic<T>`, be aware of the following:
+
+* The `T` in `SharedStatic<T>` defines the data type.
+* To identify a static field, provide a context for it. To do this, create a key for both the containing type (for example, `MutableStaticTest` in the example above), identify the field (for example, `IntFieldKey` class in the example above) and pass these classes as generic arguments of `SharedStatic<int>.GetOrCreate<MutableStaticTest, IntFieldKey>()`.
+* Always initialize the shared static field in C# from a static constructor before accessing it from HPC#. If you don't initialize the data before accessing it, it might lead to an undefined initialization state.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-static-read-only-support.md

@@ -0,0 +1,32 @@
+# Static read-only fields and static constructor support
+
+Burst evaluates all static fields and all static constructors at compile time. It evaluates all the static fields and the static constructors for a given struct together. 
+
+When there is a static field that isn't read-only in a Burst-compiled struct, a compilation error happens. This is because Burst only supports read-only static fields.
+
+When Burst fails to evaluate any static field or static constructor, all fields and constructors fail for that struct. 
+
+When compile-time evaluation fails, Burst falls back to compiling all static initialization code into an initialization function that it calls once at runtime. This means that your code needs to be Burst compatible, or it will fail compilation if it fails compile-time evaluation.
+
+An exception to this is that there's limited support for initializing static read-only array fields as long as they're initialized from either an array constructor or from static data:
+- `static readonly int[] MyArray0 = { 1, 2, 3, .. };`
+- `static readonly int[] MyArray1 = new int[10];`
+
+## Language support
+
+Burst doesn't support calling external functions and function pointers. 
+
+It supports using the following base language with static read-only fields and constructors:
+
+* Managed arrays
+* Strings
+* Limited intrinsic support:
+    * `Unity.Burst.BurstCompiler.IsEnabled`
+    * `Unity.Burst.BurstRuntime.GetHashCode32`
+    * `Unity.Burst.BurstRuntime.GetHashCode64`
+    * Vector type construction
+* Limited intrinsic assertion support:
+    * `UnityEngine.Debug.Assert`
+    * `NUnit.Framework.Assert.AreEqual`
+    * `NUnit.Framework.Assert.AreNotEqual`
+* Simple throw patterns. Any exceptions thrown during evaluation become compiler errors.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-string-support.md

@@ -0,0 +1,113 @@
+# String support
+
+Burst supports string usage in the following scenarios:
+
+* [`Debug.Log`](https://docs.unity3d.com/ScriptReference/Debug.Log.html)
+* Assigning a string to the `FixedString` structs that `Unity.Collections` provides, for example [`FixedString128`](https://docs.unity3d.com/Packages/com.unity.collections@1.2/api/Unity.Collections.FixedString128.html).
+* The [`System.Runtime.CompilerServices`](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices?view=net-6.0) attributes `[CallerLineNumber]`, `[CallerMemberName]`, and `[CallerFilePath]` on arguments to Burst functions. However, you can only pass the strings directly to calls to `Debug.Log`.
+
+A string can be either:
+* A string literal. For example: `"This is a string literal"`.
+* An interpolated string using `$"This is an integer {value}` or using `string.Format`, where the string to format is also a string literal.
+
+For example, Burst supports the following constructions:
+
+* Logging with a string literal:
+
+    ```c#
+    Debug.Log("This a string literal");
+   ```
+
+* Logging using string interpolation:
+
+    ```c#
+    int value = 256;
+    Debug.Log($"This is an integer value {value}"); 
+    ```
+
+    This is the same as using `string.Format` directly:
+
+    ```c#
+    int value = 256;
+    Debug.Log(string.Format("This is an integer value {0}", value));
+    ```
+
+## Supported `Debug.Log` methods
+
+Burst supports the following [`Debug.Log`](https://docs.unity3d.com/ScriptReference/Debug.Log.html) methods:
+
+* `Debug.Log(object)`
+* `Debug.LogWarning(object)`
+* `Debug.LogError(object)`
+
+## String interpolation support
+
+String interpolation has the following restrictions:
+
+* The string must be a string literal
+* Burst supports the following `string.Format` methods:
+    * `string.Format(string, object)` 
+    * `string.Format(string, object, object)` 
+    * `string.Format(string, object, object, object)`
+    * `string.Format(string, object[])`. Use this for a string interpolation that contains more than three arguments, for example `$"{arg1} {arg2} {arg3} {arg4} {arg5}"`. In this case, the `object[]` array needs to be a constant size and no arguments should involve control flows (for example, `$"This is a {(cond ? arg1 : arg2)}"`).
+* The string must only use value types
+* The string must take only built-in type arguments:
+    * `char`
+    * `boolean` 
+    * `byte` / `sbyte`
+    * `double`
+    * `float`
+    * `short` / `ushort`
+    * `int` / `uint`
+    * `long` / `ulong`
+* Burst supports sll vector types (for example `int2`, `float3`), except `half` vector types. For example:
+
+    ```c#
+    var value = new float3(1.0f, 2.0f, 3.0f);
+    // Logs "This value float3(1f, 2f, 3f)"
+    Debug.Log($"This value `{value}`");
+* Burst doesn't support `ToString()` of structs. It displays the full name of the struct instead.
+
+For more information, see the .NET documentation on [String interpolation](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated) and  [Standard numeric format strings](https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings).
+
+## Managed strings
+
+You can pass a managed `string` literal or an interpolated string directly to `Debug.Log`, but you can't pass a string to a user method or to use them as fields in a struct. To pass around or store strings, use one of the [`FixedString`](https://docs.unity3d.com/Packages/com.unity.collections@1.2/api/Unity.Collections.FixedString.html) structs in the `Unity.Collections` package:
+
+```c#
+int value = 256;
+FixedString128 text = $"This is an integer value {value} used with FixedString128";
+MyCustomLog(text);
+
+// ...
+
+// String can be passed as an argument to a method using a FixedString, 
+// but not using directly a managed `string`:
+public static void MyCustomLog(in FixedString128 log)
+{
+    Debug.Log(text);
+}
+```
+
+## Arguments and specifiers
+
+Burst has limited support for string format arguments and specifiers:
+
+```c#
+int value = 256;
+
+// Padding left: "This value `  256`
+Debug.Log($"This value `{value,5}`");
+
+// Padding right: "This value `256  `
+Debug.Log($"This value `{value,-5}`");
+
+// Hexadecimal uppercase: "This value `00FF`
+Debug.Log($"This value `{value:X4}`");
+
+// Hexadecimal lowercase: "This value `00ff`
+Debug.Log($"This value `{value:x4}`");
+
+// Decimal with leading-zero: "This value `0256`
+Debug.Log($"This value `{value:D4}`");
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-system-support.md

@@ -0,0 +1,43 @@
+# C#/.NET System namespace support
+
+Burst provides support for some of the `System` namespace, transforming these into Burst compatible variants in the Burst compiler.
+
+## `System.Math`
+
+Burst supports all methods that `System.Math` declares except for the following methods that aren't supported:
+ - `double IEEERemainder(double x, double y)` 
+ - `Round(double value, int digits)`
+
+## `System.IntPtr`
+
+Burst supports all methods of `System.IntPtr`/`System.UIntPtr`, including the static fields `IntPtr.Zero` and `IntPtr.Size`
+
+## `System.Threading.Interlocked`
+
+Burst supports atomic memory intrinsics for all methods provided by `System.Threading.Interlocked` (for example, `Interlocked.Increment`).
+
+Make sure that the source location of the interlocked methods are naturally aligned. For example, the alignment of the pointer is a multiple of the pointed-to-type:
+
+```c#
+[StructLayout(LayoutKind.Explicit)]
+struct Foo
+{
+    [FieldOffset(0)] public long a;
+    [FieldOffset(5)] public long b;
+
+    public long AtomicReadAndAdd()
+    {
+        return Interlocked.Read(ref a) + Interlocked.Read(ref b);
+    }
+}
+```
+
+If the pointer to the struct `Foo` has an alignment of 8, which is the natural alignment of a `long` value, the `Interlocked.Read` of `a` would be successful because it lies on a naturally aligned address. However, `b` would not be successful and undefined behavior happens at the load of `b` as a result.
+
+## `System.Threading.Thread`
+
+Burst supports the `MemoryBarrier` method of `System.Threading.Thread`.
+
+## `System.Threading.Volatile`
+
+Burst supports the non-generic variants of `Read` and `Write` provided by `System.Threading.Volatile`.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/csharp-type-support.md

@@ -0,0 +1,156 @@
+# C#/.NET type support
+
+Burst works on a subset of .NET that doesn't let you use any managed objects or reference types in your code (classes in C#).
+
+The following sections gives more details about the constructs that Burst supports, and any limitations they have.
+
+* [Built-in types](#built-in)
+* [Array types](#arrays)
+* [Struct types](#structs)
+* [Generic types](#generics)
+* [Vector types](#vectors)
+* [Enum types](#enums)
+* [Pointer types](#pointers)
+* [Span types](#spans)
+
+<a name="built-in"></a>
+
+## Built-in types
+
+### Supported built-in types
+
+Burst supports the following built-in types:
+
+* `bool`
+* `byte`/`sbyte`
+* `double`
+* `float`
+* `int`/`uint`
+* `long`/`ulong`
+* `short`/`ushort`
+
+### Unsupported built-in types
+
+Burst doesn't support the following built-in types:
+
+* `char`
+* `decimal`
+* `string` because this is a managed type
+
+<a name="arrays"></a>
+
+## Array types
+
+### Supported array types
+
+Burst supports read-only managed arrays loaded from static read-only fields:
+
+```c#
+[BurstCompile]
+public struct MyJob : IJob {
+    private static readonly int[] _preComputeTable = new int[] { 1, 2, 3, 4 };
+
+    public int Index { get; set; }
+
+    public void Execute()
+    {
+        int x = _preComputeTable[0];
+        int z = _preComputeTable[Index];
+    }
+}
+```
+
+However, accessing a static read-only managed array has the following restrictions:
+
+* You can only use the read-only static managed array directly and can't pass it around, for example as a method argument.
+* C# code that doesn't use jobs shouldn't modify the read-only static array's elements. This is because the Burst compiler makes a read-only copy of the data at compilation time.
+* Multi-dimensional arrays aren't supported.
+
+If you've used an unsupported static constructor, Burst produces the error `BC1361`.
+
+For more information on how Burst initializes arrays, see [Static readonly fields and static constructors](csharp-static-read-only-support.md).
+
+### Unsupported array types
+
+Burst doesn't support managed arrays. Instead, use a native container such as [NativeArray<T>](https://docs.unity3d.com/ScriptReference/Unity.Collections.NativeArray_1.html).
+
+
+<a name="structs"></a>
+
+## Struct types
+
+### Supported structs
+
+Burst supports the following structs:
+
+* Regular structs with any field with supported types
+* Structs with fixed array fields
+
+>[!NOTE]
+>Structs with an explicit layout might generate non-optimal native code.
+
+### Supported struct layout
+
+Burst supports the following struct layouts:
+
+* `LayoutKind.Sequential`
+* `LayoutKind.Explicit` 
+* `StructLayoutAttribute.Pack` 
+* `StructLayoutAttribute.Size` 
+
+Burst supports `System.IntPtr` and `System.UIntPtr` natively as intrinsic structs that directly represent pointers.
+
+<a name="generics"></a>
+
+## Generic types
+
+Burst supports generic types used with structs. It supports full instantiation of generic calls for generic types that have interface constraints, for example when a struct with a generic parameter needs to implement an interface.
+
+>[!NOTE]
+> There are restrictions if you use [generic jobs](compilation-generic-jobs.md).
+
+<a name="vectors"></a>
+
+## Vector types
+
+Burst can translate vector types from [`Unity.Mathematics`](https://docs.unity3d.com/Packages/com.unity.mathematics@latest) to native SIMD vector types with the following first class support for optimizations:
+
+* `bool2`/`bool3`/`bool4`
+* `uint2`/`uint3`/`uint4`
+* `int2`/`int3`/`int4`
+* `float2`/`float3`/`float4`
+
+>[!TIP]
+> For performance reasons, use the 4 wide types (`bool4`, `uint4`, `float4`, `int4`, ) over the other types.
+
+<a name="enums"></a>
+
+## Enum types
+
+### Supported enum types
+
+Burst supports all enums including enums that have a specific storage type, for example, `public enum MyEnum : short`.
+
+### Unsupported enums
+Burst doesn't support `Enum` methods, for example [`Enum.HasFlag`](https://docs.microsoft.com/en-us/dotnet/api/system.enum.hasflag?view=net-6.0).
+
+<a name="pointers"></a>
+
+## Pointer types
+
+Burst supports any pointer types to any Burst supported types
+
+<a name="spans"></a>
+
+## Span types
+
+Burst supports [`Span<T>`](https://docs.microsoft.com/en-us/dotnet/api/system.span-1?view=net-6.0) and [`ReadOnlySpan<T>`](https://docs.microsoft.com/en-us/dotnet/api/system.readonlyspan-1?view=net-6.0) types in the Unity Editors that support them.
+
+You can only use span types in Burst jobs or function-pointers, but not across the interface to them. This is because in C#'s implementation of the span types it supports taking spans into managed data types (like a managed array). For example, the following code is invalid:
+
+```c#
+[BurstCompile]
+public static void SomeFunctionPointer(Span<int> span) {}
+```
+
+This is because `Span` is used across the managed and Burst boundary. In Burst, span types respect any safety check setting, and only perform performance-intensive checks when safety checks are enabled.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/debugging-profiling-tools.md

@@ -0,0 +1,126 @@
+# Debugging and profiling tools
+
+The following sections describe how to debug and profile your Burst-compiled code in the Editor and in player builds.
+
+>[!TIP]
+>Before attempting to debug Burst-compiled code, enable script debugging for the Editor, or a player build by following the steps in [Debug C# code in Unity](xref:ManagedCodeDebugging). Although you can theoretically debug Burst-compiled code even when the script compilation mode is set to Release, in practice it doesn't work reliably. Breakpoints might be skipped, and variables might not appear in the Locals window, for example.
+
+<a name="debugging-in-editor"></a>
+
+## Debugging Burst-compiled code in the Editor
+
+To debug Burst-compiled code in the Editor, you can either use a managed debugger, or a native debugger. This section explains both options.
+
+### Attach a managed debugger
+
+You can attach a managed debugger such as Visual Studio, Visual Studio for Mac, or JetBrains Rider. This is the same type of debugger you can use to debug regular managed C# code in your Unity project. The ways of attaching a debugger differ depending on the version of Unity you're using:
+
+- **Unity 2022.2+**: When you place a breakpoint inside Burst-compiled code, and you have a managed debugger attached, Unity disables Burst automatically for that code path. This allows you to use a managed debugger to debug the managed version of your code. When you remove all breakpoints from that code path, Unity re-enables Burst for that code path.
+
+- **Unity 2022.1 and older**: Disable Burst, either with the global option in the Editor [Burst menu](editor-burst-menu.md) (**Jobs** &gt; **Burst** &gt; **Enable Compilation**), or comment out the `[BurstCompile]` attribute from the specific entry-point that you want to debug.
+
+### Attach a native debugger
+
+You can attach a native debugger such as Visual Studio or Xcode. Before doing so, you need to disable Burst optimizations. You can do this in the following ways:
+    
+- Use the **Native Debug Mode Compilation** setting in the Editor [Burst menu](editor-burst-menu.md) (**Jobs** &gt; **Burst** &gt; **Native Debug Mode Compilation**). **Important:** This setting disables optimizations across all jobs, which impacts the performance of Burst code. If you want to disable optimizations only for a specific job, use the other option in this list.
+    
+- Add the `Debug = true` flag to your job, which disables optimizations and enables debugging on that specific job:
+
+    ```c#
+    [BurstCompile(Debug = true)]
+    public struct MyJob : IJob
+    {
+        // ...
+    }
+    ```
+
+    >[!TIP]
+    >Player builds pick up the `Debug` flag, so you can also use this to debug a player build. 
+
+To attach a native debugger to the Unity Editor process, see the [native debugging](#native-debugging) section below.
+
+<a name="debugging-in-player"></a>
+
+## Debugging Burst-compiled code in a player build
+
+Because of the way that Unity builds the code for a player, you need to tell the debugging tool where to find the symbols. To do this, point the tool to the folder that contains the `lib_burst_generated` files, which is usually in the `Plugins` folder.
+
+To debug Burst-compiled code in a player build, you need to attach a native debugger (such as Visual Studio or Xcode) to the player process. Before doing so, you need to:
+
+- Enable symbol generation. You can do this in either of two ways:
+
+    - Enable the **Development Build** option before you build the player, or
+
+    - Enable the **Force Debug Information** option in [Burst AOT Player Settings](building-aot-settings.md)
+
+- Disable Burst optimizations. You can do this in either of two ways:
+
+    - Disable the **Enable Optimizations** option in [Burst AOT Player Settings](building-aot-settings.md). **Important:** This setting disables optimizations across all jobs, which impacts the performance of Burst code.  If you want to disable optimizations only for a specific job, use the other option in this list.
+
+    - Add the `Debug = true` flag to your job, which disables optimizations and enables debugging on that specific job:
+
+        ```c#
+        [BurstCompile(Debug = true)]
+        public struct MyJob : IJob
+        {
+            // ...
+        }
+        ```
+
+To attach a native debugger to the player process, see the [native debugging](#native-debugging) section below.
+
+<a name="native-debugging"></a>
+
+## Native debugging
+
+Follow the instructions above to setup native debugging correctly for the [Editor](#debugging-in-editor) or a [player build](#debugging-in-player). Then, attach a native debugger such as Visual Studio or Xcode.
+
+### Native debugging limitations
+
+* Native debuggers can't discover lambda captures on `Entity.ForEach`, so you can't inspect variables originating from these.
+* Structs that use [`[StructLayout(LayoutKind=Explicit)]`](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.layoutkind?view=net-6.0) and have overlapping fields are represented by a struct that hides one of the overlaps. 
+* Function parameters are read-only from a debugging point of view. Burst records them to a stack argument during the prologue. Changing their value in the debugger might not have an affect.
+
+### Code-based breakpoints
+
+Burst supports code-based breakpoints through the [`System.Diagnostics.Debugger.Break`](https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.debugger.break?view=net-6.0) method. This method generates a debug trap in your code. You must attach a debugger to your code so that it can intercept the break. Breakpoints trigger whether you've attached a debugger or not. 
+
+Burst adds information to track local variables, function parameters and breakpoints. If your debugger supports conditional breakpoints, use these over adding breakpoints in your code, because they only fire when you've attached a debugger.
+
+## Profiling Burst-compiled code
+
+### Profiling using standalone profiling tools
+
+You can use profiling tools (such as Instruments or Superluminal) to profile Burst-compiled code in a player build. Because of the way that Unity builds the code for a player, you need to tell the profiling tool where to find the symbols. To do this, point the tool to the folder that contains the `lib_burst_generated` files, which is usually in the `Plugins` folder.
+
+<a name="profiler-markers"></a>
+
+### Unity Profiler markers
+
+To improve the data you get from Unity Profiler (either for Burst-compiled code running in the Editor or in an attached player), you can create Unity Profiler markers from Burst code by calling `new ProfilerMarker("MarkerName")`:
+
+```c#
+[BurstCompile]
+private static class ProfilerMarkerWrapper
+{
+    private static readonly ProfilerMarker StaticMarker = new ProfilerMarker("TestStaticBurst");
+
+    [BurstCompile(CompileSynchronously = true)]
+    public static int CreateAndUseProfilerMarker(int start)
+    {
+        using (StaticMarker.Auto())
+        {
+            var p = new ProfilerMarker("TestBurst");
+            p.Begin();
+            var result = 0;
+            for (var i = start; i < start + 100000; i++)
+            {
+                result += i;
+            }
+            p.End();
+            return result;
+        }
+    }
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/editor-burst-inspector.md

@@ -0,0 +1,43 @@
+# Burst Inspector window reference
+
+The Burst Inspector window displays all the jobs and other Burst compile targets in the project. To open the Burst Inspector window, go to **Jobs** > **Burst** > **Open Inspector**.
+
+The Burst Inspector displays all the Jobs that it can compile. It also displays the generated intermediate and native assembly code.
+
+When opening a new target job in the Burst Inspector, it will try to focus the assembly directly related to the chosen bursted job. Furthermore, if branch flow arrows are shown, and they fill more than half of the assembly view, the inspector will scroll horizontally rightwards to focus the code instead of the branches.
+
+![Burst Inspector](images/burst-inspector.png)<br/>_Burst Inspector with Branch Flow enabled_
+
+## Burst Inspector panes
+
+The **Compile Targets** pane on the left of the window displays an alphabetical list of the jobs in the project that Burst can compile. By default jobs either in the Unity namespace or with ".Generated" in the name are excluded. This can be changed via the toggles **Show Unity Namespace** and **Show ".Generated"** respectively. Disabled jobs in the list don't have the `[BurstCompile]` attribute.
+
+The right output pane of the Burst Inspector window displays options to view the assembly and intermediate code for the job you've selected in the **Compile Targets** list. To expand or collapse elements of the code, select the colored boxes (some with ellipses) . By default. the Burst Inspector automatically collapses blocks that it considers non-essential, such as most directives and data.
+
+It is possible to select lines of assembly. This will highlight the selected line, by underlining it. If this line contains any registers, the usage of these registers will be highlighted throughout the code; note that implicit registers are ignored for this feature.
+
+To select and copy the text in this pane, either click and drag with your mouse, or use Shift + arrow keys to select the text. To copy the text, either right-click and select **Copy Selection**, or press Ctrl + C (Command + C on macOS). Default behavior for the Burst Inspector's copy is to include underlying color tags. To change this, right-click with the mouse on the right pane, to open up the context menu, and untick **Copy Color Tags**.
+
+At the top of the window, the following display options are available:
+
+| **Display option**                                                                              | **Function**                                                                                                                                                                                                                                                                                             |
+|-------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Output dropdown**                                                                             | Use the dropdown to select how to output the information in the Burst Inspector window                                                                                                                                                                                                                   |
+| Plain Without Debug Information                                                                 | Displays the raw output.                                                                                                                                                                                                                                                                                 |
+| Plain With Debug Information                                                                    | Displays the raw output with debug information.                                                                                                                                                                                                                                                          |
+| Enhanced with Minimal Debug Information<br/>(Only available in **Assembly** view)               | Displays the line information interweaved with the assembly to guide you to what line in your code matches what assembly output. If you've enabled **Show Branch Flow**, the branch flow indicates where jump instruction might branch off to.                                                           |
+| Enhanced With Full Debug Information<br/>(Only available in **Assembly** view)                  | Displays the same information as Enhanced with Minimal Debug Information but with debug information included.                                                                                                                                                                                            |
+| Coloured With Minimal Debug Information<br/>(Only available in **Assembly** view)               | Displays the same information as Enhanced with Minimal Debug Information, but displays the output in color.                                                                                                                                                                                              |
+| Coloured With Full Debug Information<br/>(Only available in **Assembly** view)                  | Displays the same information as Enhanced with Full Debug Information, but displays the output in color.                                                                                                                                                                                                 |
+| **Safety Checks**                                                                               | Enable this option to generate code that includes container access safety checks, for example, to check if a job is attempting to write to a read-only native container.                                                                                                                                 |
+| **Font Size**                                                                                   | Select the size of the text in the output pane.                                                                                                                                                                                                                                                          |
+| **Architecture dropdown**                                                                       | Select the target architecture for your build.                                                                                                                                                                                                                                                           |
+| **Focus on Code**<br/>(Only available in **Enhanced** or **Coloured** output)                   | Collapses the least important blocks of the disassembly. When you select this, Unity hides most of the assembly language directives and non code segments, allowing you to focus on the code itself.                                                                                                     |
+| **Expand all** <br/>(Only available in **Enhanced** or **Coloured** output)                     | Expands all collapsed blocks of disassembly and displays all the hidden assembly language directives and data elements.                                                                                                                                                                                  |
+| **Show Branch Flow**<br/>(Only available in **Enhanced** or **Coloured** output)                | Enable this option to display arrows that show branch flow in the code. When enabled, the code moves to the right, to make space to display the arrows.                                                                                                                                                  |
+| **Highlight SIMD Scalar vs Packed**<br/>(Only available in **Enhanced** or **Coloured** output) | Enable this option to display SIMD instruction differently depending on their nature (Whether they work on packed or scalar inputs). This can be used to quickly assess the quality of the generated vectorized code (see [SIMD smell test by Andreas Fredriksson](https://youtu.be/BpwvXkoFcp8?t=447)). |                                                                                                                                                                                                |
+| **Assembly**                                                                                    | Displays the final optimized native code that Burst generated.                                                                                                                                                                                                                                           |
+| **.NET IL**                                                                                     | Displays the original .NET IL extracted from the job method.                                                                                                                                                                                                                                             |
+| **LLVM IR (Unoptimized)**                                                                       | Displays the internal LLVM IR before optimizations.                                                                                                                                                                                                                                                      |
+| **LLVM IR (Optimized)**                                                                         | Displays the internal LLVM IR after optimizations.                                                                                                                                                                                                                                                       |
+| **LLVM IR Optimization Diagnostics**                                                            | Displays LLVM diagnostics of the optimizations, such as if they succeeded or failed.                                                                                                                                                                                                                     |

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/editor-burst-menu.md

@@ -0,0 +1,52 @@
+# Burst menu reference
+
+In the Editor, use the settings in the Burst menu to control how Burst works. To access this menu, go to **Jobs > Burst**. The following settings are available:
+
+|**Setting**|**Function**|
+|---|---|
+|**Enable Compilation**| Enable this setting to activate Burst compilation. When you enable this setting, Burst compiles jobs and Burst custom delegates that you tag with the attribute `[BurstCompile]`.|
+|**Enable Safety Checks**| Choose what safety checks Burst should use. For more information see the [Enable Safety Checks setting](#safety-checks) section of this documentation.|
+|Off| Disable safety checks across all Burst jobs and function-pointers. Only use this setting if you want more realistic profiling results from in-Editor captures. When you reload the Editor, this setting always resets to **On**. |
+|On| Enable safety checks on code that uses collection containers (e.g `NativeArray<T>`). Checks include job data dependency and container indexes out of bounds. This is the default setting.|
+|Force On| Force safety checks on even for jobs and function-pointers that have [`DisableSafetyChecks = true`](xref:Unity.Burst.BurstCompileAttribute.DisableSafetyChecks). Use this setting to rule out any problems that safety checks might have caught.|
+|**Synchronous Compilation**| Enable this setting to compile Burst synchronously. For more information, see [Synchronous compilation](compilation-synchronous.md).|
+|**Native Debug Mode Compilation**| Enable this setting to deactivate optimizations on all code that Burst compiles. This makes it easier to debug via a native debugger. For more information, see [Native Debugging tools](debugging-profiling-tools.md#native-debugging). |
+|**Show Timings**| Enable this setting to log the time it takes to JIT compile a job in the Editor and display it in the Console. For more information see the [Show Timings setting](#show-timings) section of this documentation.|
+|**Open Inspector**| Opens the [Burst Inspector window](editor-burst-inspector.md).|
+
+<a name="safety-checks"></a>
+
+## Enable Safety Checks setting
+
+To disable Burst's safety check code, use [DisableSafetyChecks](xref:Unity.Burst.BurstCompileAttribute.DisableSafetyChecks). This results in faster code generation, however make sure that you use containers in a safe fashion.
+
+To disable safety checks on a job or function-pointer set `DisableSafetyChecks` to `true`:
+
+```c#
+[BurstCompile(DisableSafetyChecks = true)]
+public struct MyJob : IJob
+{
+    // ...
+}
+```
+
+Burst ignores code marked explicitly with `DisableSafetyChecks = true` when it safety checks your code if you set **Enable Safety Checks** to **On** in the Editor. Select **Force On** to make Burst to safety check all code, including code marked with `DisableSafetyChecks = true`.
+
+<a name="show-timings"></a>
+
+## Show Timings setting
+
+When you enable the **Show Timings** setting, Unity logs an output in the [Console window](https://docs.unity3d.com/Manual/Console.html) for each library of entry points that Burst compiles. Burst batches the compilation into units of methods-per-assembly, and groups multiple entry-points together in a single compilation task. This output is useful if you want to report outliers in compilation to the Burst compiler team (via the [Burst forum](https://forum.unity.com/forums/burst.629/)). 
+
+Unity splits Burst's output into the following major sections:
+
+* Method discovery (where Burst works out what it needs to compile)
+* Front end (where Burst turns C# IL into an LLVM IR module)
+* Middle end (where Burst specializes, optimizes, and cleans up the module)
+* Back-end (where Burst turns the LLVM IR module into a native DLL)
+
+The compile time in the front end and optimizer is linear to the amount operations that it needs to compile. More functions and more instructions means a longer compile time. The more generic functions you have, the higher the front end performance timings, because generic resolutions have non-zero costs.
+
+The compile time in the back-end scales with the number of entry-points in the module. This is because each entry point is in its own native object file.
+
+If the optimizer takes a significant amount of time, use `[BurstCompile(OptimizeFor = OptimizeFor.FastCompilation)]` which reduces the optimizations that Burst does, but compiles things much faster. Profile the job before and after to make sure that this tradeoff is right for that entry-point.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/editor-reference-overview.md

@@ -0,0 +1,12 @@
+# Editor reference
+
+Explore the specific Burst Editor features.
+
+|**Topic**|**Description**|
+|---|---|
+|[Burst menu](editor-burst-menu.md)|Use the Burst menu to control the Burst settings in your project.|
+|[Burst Inspector](editor-burst-inspector.md)|Use the Burst Inspector to see the jobs and Burst compiled targets in your project.|
+
+## Additional resources
+
+* [Building your project](building-projects.md)

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/filter.yml

@@ -0,0 +1,4 @@
+apiRules:
+  - exclude:
+      uidRegex: ^Global Namespace.*
+      type: Namespace

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/getting-started.md

@@ -0,0 +1,70 @@
+# Getting started
+
+Burst is primarily designed to work with Unity's [job system](https://docs.unity3d.com/Manual/JobSystem.html). To start using the Burst compiler in your code, decorate a [Job struct](https://docs.unity3d.com/ScriptReference/Unity.Jobs.IJob.html) with the [`[BurstCompile]`](xref:Unity.Burst.BurstCompileAttribute) attribute. Add the `[BurstCompile]` attribute to the type and the static method you want Burst to compile.
+
+
+```c#
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using UnityEngine;
+
+public class MyBurst2Behavior : MonoBehaviour
+{
+    void Start()
+    {
+        var input = new NativeArray<float>(10, Allocator.Persistent);
+        var output = new NativeArray<float>(1, Allocator.Persistent);
+        for (int i = 0; i < input.Length; i++)
+            input[i] = 1.0f * i;
+
+        var job = new MyJob
+        {
+            Input = input,
+            Output = output
+        };
+        job.Schedule().Complete();
+
+        Debug.Log("The result of the sum is: " + output[0]);
+        input.Dispose();
+        output.Dispose();
+    }
+
+    // Using BurstCompile to compile a Job with Burst
+
+    [BurstCompile]
+    private struct MyJob : IJob
+    {
+        [ReadOnly]
+        public NativeArray<float> Input;
+
+        [WriteOnly]
+        public NativeArray<float> Output;
+
+        public void Execute()
+        {
+            float result = 0.0f;
+            for (int i = 0; i < Input.Length; i++)
+            {
+                result += Input[i];
+            }
+            Output[0] = result;
+        }
+    }
+}
+```
+
+## Limitations
+
+Burst supports most C# expressions and statements, with a few exceptions. For more information, see [C# language support](csharp-language-support.md).
+
+## Compilation
+
+Burst compiles your code [just-in-time (JIT)](https://en.wikipedia.org/wiki/Just-in-time_compilation) while in Play mode in the Editor, and [ahead-of-time (AOT)](https://en.wikipedia.org/wiki/Ahead-of-time_compilation) when your application runs in a Player. For more information on compilation, see [Burst compilation](compilation.md)
+
+## Command line options
+
+You can pass the following options to the Unity Editor on the command line to control Burst:
+
+- `--burst-disable-compilation` disables Burst.
+- `--burst-force-sync-compilation` force Burst to compile synchronously. For more information, see [Burst compilation](compilation.md).

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/index.md

@@ -0,0 +1,34 @@
+# About Burst 
+
+Burst is a compiler that you can use with Unity's [job system](https://docs.unity3d.com/Manual/JobSystem.html) to create code that enhances and improves your application's performance. It translates your code from IL/.NET bytecode to optimized native CPU code that uses the [LLVM compiler](https://llvm.org/). 
+
+## Installation
+To install this package, follow the instructions in the [Package Manager documentation](https://docs.unity3d.com/Manual/upm-ui-actions.html).
+
+If you change the Burst package version (for example, via Update), you need to close and restart the Editor.
+
+
+## Further resources
+
+### Videos
+
+Conference presentations given by the Burst team:
+
+* [Getting started with Burst - Unite Copenhagen 2019](https://www.youtube.com/watch?v=Tzn-nX9hK1o) ([slides](https://docs.google.com/presentation/d/1id50G18EnRroQaq1apIDU9MrcxhaSihhqPoQrmn1mBg))
+* [Supercharging mobile performance with ARM Neon and Unity Burst Compiler](https://www.youtube.com/watch?v=7iEUvlUyr4k)
+* [Using Burst Compiler to optimize for Android - Unite Now 2020](https://www.youtube.com/watch?v=WnJV6J-taIM) 
+* [Intrinsics: Low-level engine development with Burst - Unite Copenhagen 2019](https://www.youtube.com/watch?v=BpwvXkoFcp8) ([slides](https://www.slideshare.net/unity3d/intrinsics-lowlevel-engine-development-with-burst))
+* [Behind the Burst compiler: Converting .NET IL to highly optimized native code - DotNext 2018](https://www.youtube.com/watch?v=LKpyaVrby04)
+* [Deep dive into the Burst compiler - Unite LA 2018](https://www.youtube.com/watch?v=QkM6zEGFhDY)
+* [C# to machine code: GDC 2018](https://www.youtube.com/watch?v=NF6kcNS6U80)
+* [Using the native debugger for Burst compiled code](https://www.youtube.com/watch?v=nou6AIHKJz0)
+
+### Blogs
+
+Blog posts written by members of the Burst team :
+
+* [Raising your game with Burst 1.7](https://blog.unity.com/technology/raising-your-game-with-burst-17)
+* [Enhancing mobile performance with the Burst compiler](https://blog.unity.com/technology/enhancing-mobile-performance-with-the-burst-compiler)
+* [Enhanced aliasing with Burst](https://blogs.unity3d.com/2020/09/07/enhanced-aliasing-with-burst/)
+* [In parameters in Burst](https://blogs.unity3d.com/2020/11/25/in-parameters-in-burst/)
+

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/modding-support.md

@@ -0,0 +1,241 @@
+# Modding support 
+
+From Unity 2021.1, you can load additional Burst compiled libraries, which provide a way to create modifications that use Burst compiled code. 
+
+Burst only provides a method to load additional libraries, and doesn't provide any tooling to create mods. You need a copy of the Unity Editor to compile the additional libraries. 
+
+This section gives an example approach to modding with Burst and is a proof of concept. 
+
+## Supported uses
+
+You can use this function in Play mode (or Standalone Players) only.
+
+Make sure you load the libraries as soon as possible, and before the first Burst compiled use of a C# method. Unity unloads any Burst libraries that `BurstRuntime.LoadAdditionalLibraries` loads when you exit Play mode in the Editor, quit a Standalone Player.
+
+## Example modding system
+
+>[!NOTE]
+>This example is limited in scope. You should have knowledge of assemblies and asmdefs to follow this example.
+
+This example declares an interface that the mods abide by:
+
+```c#
+using UnityEngine;
+
+public interface PluginModule
+{
+    void Startup(GameObject gameObject);
+    void Update(GameObject gameObject);
+}
+```
+
+You can use this interface to create new classes which follow these specifications and ship it separate to your application. Passing a single `GameObject` along limits the state that the plug-ins can affect. 
+
+### Modding manager
+
+The following is an example of a modding manager:
+
+```c#
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using UnityEngine;
+using Unity.Burst;
+
+public class PluginManager : MonoBehaviour
+{
+    public bool modsEnabled;
+    public GameObject objectForPlugins;
+
+    List<PluginModule> plugins;
+
+    void Start()
+    {
+        plugins = new List<PluginModule>();
+
+        // If mods are disabled, early out - this allows us to disable mods, enter Play Mode, exit Play Mode
+        //and be sure that the managed assemblies have been unloaded (assuming DomainReload occurs)
+        if (!modsEnabled)
+            return;
+
+        var folder = Path.GetFullPath(Path.Combine(Application.dataPath, "..", "Mods"));
+        if (Directory.Exists(folder))
+        {
+            var mods = Directory.GetDirectories(folder);
+
+            foreach (var mod in mods)
+            {
+                var modName = Path.GetFileName(mod);
+                var monoAssembly = Path.Combine(mod, $"{modName}_managed.dll");
+
+                if (File.Exists(monoAssembly))
+                {
+                    var managedPlugin = Assembly.LoadFile(monoAssembly);
+
+                    var pluginModule = managedPlugin.GetType("MyPluginModule");
+
+                    var plugin = Activator.CreateInstance(pluginModule) as PluginModule;
+
+                    plugins.Add(plugin);
+                }
+
+                var burstedAssembly = Path.Combine(mod, $"{modName}_win_x86_64.dll");      // Burst dll (assuming windows 64bit)
+                if (File.Exists(burstedAssembly))
+                {
+                    BurstRuntime.LoadAdditionalLibrary(burstedAssembly);
+                }
+            }
+        }
+
+        foreach (var plugin in plugins)
+        {
+            plugin.Startup(objectForPlugins);
+        }
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        foreach (var plugin in plugins)
+        {
+            plugin.Update(objectForPlugins);
+        }
+    }
+}
+
+```
+
+This code scans the "Mods" folder, and for each folder it finds within, it attempts to load both a managed dll and a Burst compiled dll. It does this by adding them to an internal list that it can then iterate on and call the respective interface functions. 
+
+The names of the files are arbitrary: see [Simple Create Mod Menu Button](#simple-create-mod-menu-button), which is the code that generated those files.
+
+Because this code loads the managed assemblies into the current domain, you need a domain reload to unload those before you can overwrite them. Unity automatically unloads the Burst dll files automatically unloaded when you exit Play mode. This is why a Boolean to disable the modding system is included, for testing in the Editor.
+
+### A mod that uses Burst 
+
+Create a separate Unity project for this to use the project to produce the mod.
+
+The following script attaches to a UI Canvas that contains a text component called **Main UI Label**, and changes the text when the mod is used. The text is either **Plugin Updated : Bursted** or **Plugin Updated : Not Bursted**. You will see the **Plugin Updated : Bursted** by default, but if you comment out the lines that load the Burst library in the PluginManager above, then the Burst compiled code doesn't load and the message changes appropriately. 
+
+```c#
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class MyPluginModule : PluginModule
+{
+    Text textComponent;
+
+    public void Startup(GameObject gameObject)
+    {
+        var childTextComponents = gameObject.GetComponentsInChildren<Text>();
+        textComponent = null;
+        foreach (var child in childTextComponents)
+        {
+            if (child.name == "Main UI Label")
+            {
+                textComponent = child;
+            }
+        }
+
+        if (textComponent==null)
+        {
+            Debug.LogError("something went wrong and i couldn't find the UI component i wanted to modify");
+        }
+    }
+
+    public void Update(GameObject gameObject)
+    {
+        if (textComponent != null)
+        {
+            var t = new CheckBurstedJob { flag = new NativeArray<int>(1, Allocator.TempJob, NativeArrayOptions.UninitializedMemory) };
+
+            t.Run();
+
+            if (t.flag[0] == 0)
+                textComponent.text = "Plugin Updated : Not Bursted";
+            else
+                textComponent.text = "Plugin Updated : Bursted";
+
+            t.flag.Dispose();
+        }
+    }
+
+    [BurstCompile]
+    struct CheckBurstedJob : IJob
+    {
+        public NativeArray<int> flag;
+
+        [BurstDiscard]
+        void CheckBurst()
+        {
+            flag[0] = 0;
+        }
+
+        public void Execute()
+        {
+            flag[0] = 1;
+            CheckBurst();
+        }
+    }
+
+}
+
+```
+
+Put the above script in a folder along with an assembly definition file with an assembly name of `TestMod_Managed`, so that the next script can locate the managed part. 
+
+### Simple Create Mod Menu button
+
+The below script adds a menu button. When you use the menu button, it builds a Standalone Player, then copies the C# managed dll and the `lib_burst_generated`.dll into a chosen Mod folder. This example assumes you are using Windows.
+
+```c#
+using UnityEditor;
+using System.IO;
+using UnityEngine;
+
+public class ScriptBatch
+{
+    [MenuItem("Modding/Build X64 Mod (Example)")]
+    public static void BuildGame()
+    {
+        string modName = "TestMod";
+
+        string projectFolder = Path.Combine(Application.dataPath, "..");
+        string buildFolder = Path.Combine(projectFolder, "PluginTemp");
+
+        // Get filename.
+        string path = EditorUtility.SaveFolderPanel("Choose Final Mod Location", "", "");
+
+        FileUtil.DeleteFileOrDirectory(buildFolder);
+        Directory.CreateDirectory(buildFolder);
+
+        // Build player.
+        var report = BuildPipeline.BuildPlayer(new[] { "Assets/Scenes/SampleScene.unity" }, Path.Combine(buildFolder, $"{modName}.exe"), BuildTarget.StandaloneWindows64, BuildOptions.Development);
+
+        if (report.summary.result == UnityEditor.Build.Reporting.BuildResult.Succeeded)
+        {
+            // Copy Managed library
+            var managedDest = Path.Combine(path, $"{modName}_Managed.dll");
+            var managedSrc = Path.Combine(buildFolder, $"{modName}_Data/Managed/{modName}_Managed.dll");
+            FileUtil.DeleteFileOrDirectory(managedDest);
+            if (!File.Exists(managedDest))  // Managed side not unloaded
+                FileUtil.CopyFileOrDirectory(managedSrc, managedDest);
+            else
+                Debug.LogWarning($"Couldn't update manged dll, {managedDest} is it currently in use?");
+
+            // Copy Burst library
+            var burstedDest = Path.Combine(path, $"{modName}_win_x86_64.dll");
+            var burstedSrc = Path.Combine(buildFolder, $"{modName}_Data/Plugins/x86_64/lib_burst_generated.dll");
+            FileUtil.DeleteFileOrDirectory(burstedDest);
+            if (!File.Exists(burstedDest))
+                FileUtil.CopyFileOrDirectory(burstedSrc, burstedDest);
+            else
+                Debug.LogWarning($"Couldn't update bursted dll, {burstedDest} is it currently in use?");
+        }
+    }
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/optimization-assumerange.md

@@ -0,0 +1,65 @@
+# AssumeRange attribute
+
+Use the [`AssumeRange`](xref:Unity.Burst.CompilerServices.AssumeRangeAttribute) attribute to tell Burst that a given scalar-integer lies within a certain constrained range. If Burst has this information, it can improve the performance of your application. The following code is an example of this:
+
+```c#
+[return:AssumeRange(0u, 13u)]
+static uint WithConstrainedRange([AssumeRange(0, 26)] int x)
+{
+    return (uint)x / 2u;
+}
+```
+
+This example tells Burst the following:
+
+* The variable `x` is in the closed-interval range `[0..26]`, or more plainly that `x >= 0 && x <= 26`.
+* The return value from `WithConstrainedRange` is in the closed-interval range `[0..13]`, or more plainly that `x >= 0 && x <= 13`.
+
+Burst uses these assumptions to create better code generation. However, there are some restrictions:
+
+* You can only place these on scalar-integer (signed or unsigned) types.
+* The type of the range arguments must match the type being attributed.
+
+Burst has deductions for the `.Length` property of `NativeArray` and `NativeSlice` which indicates that these always return non-negative integers:
+
+```c#
+static bool IsLengthNegative(NativeArray<float> na)
+{
+    // Burst always replaces this with the constant false
+    return na.Length < 0;
+}
+```
+
+For example, if you have a container like the following:
+
+```c#
+struct MyContainer
+{
+    public int Length;
+    
+    // Some other data...
+}
+```
+
+The following example shows how to tell Burst that `Length` is always a positive integer:
+
+```c#
+struct MyContainer
+{
+    private int _length;
+
+    [return: AssumeRange(0, int.MaxValue)]
+    private int LengthGetter()
+    {
+        return _length;
+    }
+
+    public int Length
+    {
+        get => LengthGetter();
+        set => _length = value;
+    }
+
+    // Some other data...
+}
+```

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/optimization-constant.md

@@ -0,0 +1,37 @@
+# Constant intrinsic
+
+Use the [`IsConstantExpression`](xref:Unity.Burst.CompilerServices.Constant.IsConstantExpression*) intrinsic to check if a given expression is constant at compile-time:
+
+```c#
+using static Unity.Burst.CompilerServices.Constant;
+
+var somethingWhichWillBeConstantFolded = math.pow(42.0f, 42.0f);
+
+if (IsConstantExpression(somethingWhichWillBeConstantFolded))
+{
+    // Burst knows that somethingWhichWillBeConstantFolded is a compile-time constant
+}
+```
+
+This is useful to check if a complex expression is always constant folded. You can use it for optimizations for a known constant value. For example, if you want to implement a `pow`-like function for integer powers:
+
+```c#
+using static Unity.Burst.CompilerServices.Constant;
+
+public static float MyAwesomePow(float f, int i)
+{
+    if (IsConstantExpression(i) && (2 == i))
+    {
+        return f * f;
+    }
+    else
+    {
+        return math.pow(f, (float)i);
+    }
+}
+```
+
+The `IsConstantExpression` check means that Burst always removes the branch  if `i` isn't constant, because the if condition is false. This means that if `i` is constant and is equal to 2, you can use a more optimal simple multiply instead.
+
+>[!NOTE]
+> Constant folding only takes place during optimizations. If you've disabled optimizations, the intrinsic returns false.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/optimization-hint.md

@@ -0,0 +1,63 @@
+# Hint intrinsics
+
+Use the [`Hint`](xref:Unity.Burst.CompilerServices.Hint) intrinsics to add information to your code which helps with Burst optimization. It has the following methods:
+
+* [`Unity.Burst.CompilerServices.Hint.Likely`](xref:Unity.Burst.CompilerServices.Hint.Likely*): Tells Burst that a Boolean condition is likely to be true.
+* [`Unity.Burst.CompilerServices.Hint.Unlikely`](xref:Unity.Burst.CompilerServices.Hint.Unlikely*): Tells Burst that a Boolean condition is unlikely to be true.
+* [`Unity.Burst.CompilerServices.Hint.Assume`](xref:Unity.Burst.CompilerServices.Hint.Assume*): Tells Burst that it can assume a Boolean condition is true.
+
+## Likely intrinsic
+
+The `Likely` intrinsic is most useful to tell Burst which branch condition has a high probability of being true. This means that Burst can focus on the branch in question for optimization purposes:
+
+```c#
+if (Unity.Burst.CompilerServices.Hint.Likely(b))
+{
+    // Any code in here will be optimized by Burst with the assumption that we'll probably get here!
+}
+else
+{
+    // Whereas the code in here will be kept out of the way of the optimizer.
+}
+```
+
+## Unlikely intrinsic
+
+The `Unlikely` intrinsic tells Burst the opposite of the `Likely` intrinsic: the condition is unlikely to be true, and it should optimize against it:
+
+```c#
+if (Unity.Burst.CompilerServices.Hint.Unlikely(b))
+{
+    // Whereas the code in here will be kept out of the way of the optimizer.
+}
+else
+{
+    // Any code in here will be optimized by Burst with the assumption that we'll probably get here!
+}
+```
+
+The `Likely` and `Unlikely` intrinsics make sure that Burst places the code most likely to be hit after the branching condition in the binary. This means that the code has a high probability of being in the instruction cache. Burst can also hoist the code out of the likely branch and spend extra time optimizing it, and not spend as much time looking at the unlikely code.
+
+An example of an unlikely branch is to check if result of an allocation is valid. The allocation is valid most of all the time, so you want the code to be fast with that assumption, but you want an error case to fall back to.
+
+## Assume intrinsic
+
+The `Assume` intrinsic is powerful. Use it with caution because it tells Burst that a condition is always true.
+
+>[!WARNING]
+>When you use `Assume`, Burst assumes the value is true without checking whether it's true.
+
+```c#
+Unity.Burst.CompilerServices.Hint.Assume(b);
+
+if (b)
+{
+    // Burst has been told that b is always true, so this branch will always be taken.
+}
+else
+{
+    // Any code in here will be removed from the program because b is always true!
+}
+```
+
+Use the `Assume` intrinsic to arbitrarily tell Burst that something is true. For example, you can use `Assume` to tell Burst to assume that a loop end is always a multiple of 16, which means that it can provide perfect vectorization without any scalar spilling for that loop. You could also use it to tell Burst that a value isn't `NaN`, or it's negative.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/optimization-loop-vectorization.md

@@ -0,0 +1,128 @@
+# Loop vectorization
+
+Burst uses [loop vectorization](https://llvm.org/docs/Vectorizers.html#loop-vectorizer) to improve the performance of your code. It uses this technique to loop over multiple values at the same time, rather than looping over single values at a time, which speeds up the performance of your code. For example:
+
+``` c#
+[MethodImpl(MethodImplOptions.NoInlining)]
+private static unsafe void Bar([NoAlias] int* a, [NoAlias] int* b, int count)
+{
+    for (var i = 0; i < count; i++)
+    {
+        a[i] += b[i];
+    }
+}
+
+public static unsafe void Foo(int count)
+{
+    var a = stackalloc int[count];
+    var b = stackalloc int[count];
+
+    Bar(a, b, count);
+}
+```
+
+Burst converts the scalar loop in `Bar` into a vectorized loop. Then, instead of looping over a single value at a time, it generates code that loops over multiple values at the same time, which produces faster code. 
+
+This is the `x64` assembly Burst generates for `AVX2` for the loop in `Bar` above:
+
+```x86asm
+.LBB1_4:
+    vmovdqu    ymm0, ymmword ptr [rdx + 4*rax]
+    vmovdqu    ymm1, ymmword ptr [rdx + 4*rax + 32]
+    vmovdqu    ymm2, ymmword ptr [rdx + 4*rax + 64]
+    vmovdqu    ymm3, ymmword ptr [rdx + 4*rax + 96]
+    vpaddd     ymm0, ymm0, ymmword ptr [rcx + 4*rax]
+    vpaddd     ymm1, ymm1, ymmword ptr [rcx + 4*rax + 32]
+    vpaddd     ymm2, ymm2, ymmword ptr [rcx + 4*rax + 64]
+    vpaddd     ymm3, ymm3, ymmword ptr [rcx + 4*rax + 96]
+    vmovdqu    ymmword ptr [rcx + 4*rax], ymm0
+    vmovdqu    ymmword ptr [rcx + 4*rax + 32], ymm1
+    vmovdqu    ymmword ptr [rcx + 4*rax + 64], ymm2
+    vmovdqu    ymmword ptr [rcx + 4*rax + 96], ymm3
+    add        rax, 32
+    cmp        r8, rax
+    jne        .LBB1_4
+```
+
+Burst has unrolled and vectorized the loop into four `vpaddd` instructions, which calculate eight integer additions each, for a total of 32 integer additions per loop iteration.
+
+## Loop vectorization intrinsics
+
+Burst includes experimental intrinsics to express loop vectorization assumptions: `Loop.ExpectVectorized` and `Loop.ExpectNotVectorized`. Burst then validates the loop vectorization at compile-time. This is useful in a situation where you might break the auto vectorization. For example, if you introduce a branch to the code:
+
+``` c#
+[MethodImpl(MethodImplOptions.NoInlining)]
+private static unsafe void Bar([NoAlias] int* a, [NoAlias] int* b, int count)
+{
+    for (var i = 0; i < count; i++)
+    {
+        if (a[i] > b[i])
+        {
+            break;
+        }
+
+        a[i] += b[i];
+    }
+}
+```
+
+This changes the assembly to the following:
+
+```x86asm
+.LBB1_3:
+    mov        r9d, dword ptr [rcx + 4*r10]
+    mov        eax, dword ptr [rdx + 4*r10]
+    cmp        r9d, eax
+    jg        .LBB1_4
+    add        eax, r9d
+    mov        dword ptr [rcx + 4*r10], eax
+    inc        r10
+    cmp        r8, r10
+    jne        .LBB1_3
+```
+
+This isn't ideal because the loop is scalar and only has 1 integer addition per loop iteration. It can be difficult to spot this happening in your code, so use the experimental intrinsics `Loop.ExpectVectorized` and `Loop.ExpectNotVectorized` to express loop vectorization assumptions. Burst then validates the loop vectorization at compile-time.
+
+Because the intrinsics are experimental, you need to use the `UNITY_BURST_EXPERIMENTAL_LOOP_INTRINSICS` preprocessor define to enable them.
+
+The following example shows the original `Bar` example with the `Loop.ExpectVectorized` intrinsic:
+
+``` c#
+[MethodImpl(MethodImplOptions.NoInlining)]
+private static unsafe void Bar([NoAlias] int* a, [NoAlias] int* b, int count)
+{
+    for (var i = 0; i < count; i++)
+    {
+        Unity.Burst.CompilerServices.Loop.ExpectVectorized();
+
+        a[i] += b[i];
+    }
+}
+```
+
+Burst then validates at compile-time whether the loop is vectorized. If the loop isn't vectorized, Burst emits a compiler error. The following example produces an error:
+
+``` c#
+[MethodImpl(MethodImplOptions.NoInlining)]
+private static unsafe void Bar([NoAlias] int* a, [NoAlias] int* b, int count)
+{
+    for (var i = 0; i < count; i++)
+    {
+        Unity.Burst.CompilerServices.Loop.ExpectVectorized();
+
+        if (a[i] > b[i])
+        {
+            break;
+        }
+
+        a[i] += b[i];
+    }
+}
+```
+
+Burst emits the following error at compile-time:
+
+>LoopIntrinsics.cs(6,9): Burst error BC1321: The loop is not vectorized where it was expected that it is vectorized.
+
+>[!IMPORTANT]
+>These intrinsics don't work inside `if` statements. Burst doesn't prevent this from happening, so you won't see a compile-time error for this.

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/optimization-overview.md

@@ -0,0 +1,17 @@
+# Optimization
+
+Best practices around optimizing Burst-compiled code.
+
+|**Topic**|**Description**|
+|---|---|
+|[Debugging and profiling tools](debugging-profiling-tools.md)|Debug and profile your Burst-compiled code in the Editor and in player builds.|
+|[Loop vectorization optimization](optimization-loop-vectorization.md)| Understand how Burst uses loop vectorization to optimize your code.|
+|[Memory aliasing](aliasing.md)| Use memory aliasing to tell Burst how your code uses data.|
+|[AssumeRange attribute](optimization-assumerange.md)| Use AssumeRange to tell Burst a given scalar-integer lies within a certain constrained range.|
+|[Hint intrinsic](optimization-hint.md)| Use the Hint intrinsic to give Burst more information about your data.|
+|[Constant intrinsic](optimization-constant.md)| Use IsConstantExpression top check if an expression is constant at run time.|
+|[SkipLocalsInit attribute](optimization-skiplocalsinit.md)|Use SkipLocalsInitAttribute to tell Burst that any stack allocations within a method don't have to be initialized to zero.|
+
+## Additional resources
+
+* [Burst intrinsics](csharp-burst-intrinsics.md)

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/optimization-skiplocalsinit.md

@@ -0,0 +1,196 @@
+# SkipLocalsInit attribute
+
+Use [`SkipLocalsInitAttribute`](xref:Unity.Burst.CompilerServices.SkipLocalsInitAttribute), to tell Burst that any stack allocations within a method don't have to be initialized to zero.
+
+In C# all local variables are initialized to zero by default. This is useful because it means an entire class of bugs surrounding undefined data disappears. But this can impact runtime performance, because initializing this data to zero takes work:
+
+```c#
+static unsafe int DoSomethingWithLUT(int* data);
+
+static unsafe int DoSomething(int size)
+{
+    int* data = stackalloc int[size];
+
+    // Initialize every field of data to be an incrementing set of values.
+    for (int i = 0; i < size; i++)
+    {
+        data[i] = i;
+    }
+
+    // Use the data elsewhere.
+    return DoSomethingWithLUT(data);
+}
+```
+
+The X86 assembly for this is:
+
+```x86asm
+        push    rbp
+        .seh_pushreg rbp
+        push    rsi
+        .seh_pushreg rsi
+        push    rdi
+        .seh_pushreg rdi
+        mov     rbp, rsp
+        .seh_setframe rbp, 0
+        .seh_endprologue
+        mov     edi, ecx
+        lea     r8d, [4*rdi]
+        lea     rax, [r8 + 15]
+        and     rax, -16
+        movabs  r11, offset __chkstk
+        call    r11
+        sub     rsp, rax
+        mov     rsi, rsp
+        sub     rsp, 32
+        movabs  rax, offset burst.memset.inline.X64_SSE4.i32@@32
+        mov     rcx, rsi
+        xor     edx, edx
+        xor     r9d, r9d
+        call    rax
+        add     rsp, 32
+        test    edi, edi
+        jle     .LBB0_7
+        mov     eax, edi
+        cmp     edi, 8
+        jae     .LBB0_3
+        xor     ecx, ecx
+        jmp     .LBB0_6
+.LBB0_3:
+        mov     ecx, eax
+        and     ecx, -8
+        movabs  rdx, offset __xmm@00000003000000020000000100000000
+        movdqa  xmm0, xmmword ptr [rdx]
+        mov     rdx, rsi
+        add     rdx, 16
+        movabs  rdi, offset __xmm@00000004000000040000000400000004
+        movdqa  xmm1, xmmword ptr [rdi]
+        movabs  rdi, offset __xmm@00000008000000080000000800000008
+        movdqa  xmm2, xmmword ptr [rdi]
+        mov     rdi, rcx
+        .p2align        4, 0x90
+.LBB0_4:
+        movdqa  xmm3, xmm0
+        paddd   xmm3, xmm1
+        movdqu  xmmword ptr [rdx - 16], xmm0
+        movdqu  xmmword ptr [rdx], xmm3
+        paddd   xmm0, xmm2
+        add     rdx, 32
+        add     rdi, -8
+        jne     .LBB0_4
+        cmp     rcx, rax
+        je      .LBB0_7
+        .p2align        4, 0x90
+.LBB0_6:
+        mov     dword ptr [rsi + 4*rcx], ecx
+        inc     rcx
+        cmp     rax, rcx
+        jne     .LBB0_6
+.LBB0_7:
+        sub     rsp, 32
+        movabs  rax, offset "DoSomethingWithLUT"
+        mov     rcx, rsi
+        call    rax
+        nop
+        mov     rsp, rbp
+        pop     rdi
+        pop     rsi
+        pop     rbp
+        ret
+```
+
+In this example, the `movabs  rax, offset burst.memset.inline.X64_SSE4.i32@@32` line means that you've had to inject a memset to zero out the data. In the above example, you know that the array is entirely initialized in the following loop, but Burst doesn't know that. 
+
+To fix this problem, use [`Unity.Burst.CompilerServices.SkipLocalsInitAttribute`](xref:Unity.Burst.CompilerServices.SkipLocalsInitAttribute), which tells Burst that any stack allocations within a method don't have to be initialized to zero. 
+
+>[!NOTE]
+>Only use this attribute if you're certain that you won't run into undefined behavior bugs. 
+
+For example:
+
+```c#
+using Unity.Burst.CompilerServices;
+
+static unsafe int DoSomethingWithLUT(int* data);
+
+[SkipLocalsInit]
+static unsafe int DoSomething(int size)
+{
+    int* data = stackalloc int[size];
+
+    // Initialize every field of data to be an incrementing set of values.
+    for (int i = 0; i < size; i++)
+    {
+        data[i] = i;
+    }
+
+    // Use the data elsewhere.
+    return DoSomethingWithLUT(data);
+}
+```
+
+The assembly after adding the `[SkipLocalsInit]` on the method is:
+
+```x86asm
+        push    rbp
+        .seh_pushreg rbp
+        mov     rbp, rsp
+        .seh_setframe rbp, 0
+        .seh_endprologue
+        mov     edx, ecx
+        lea     eax, [4*rdx]
+        add     rax, 15
+        and     rax, -16
+        movabs  r11, offset __chkstk
+        call    r11
+        sub     rsp, rax
+        mov     rcx, rsp
+        test    edx, edx
+        jle     .LBB0_7
+        mov     r8d, edx
+        cmp     edx, 8
+        jae     .LBB0_3
+        xor     r10d, r10d
+        jmp     .LBB0_6
+.LBB0_3:
+        mov     r10d, r8d
+        and     r10d, -8
+        movabs  rax, offset __xmm@00000003000000020000000100000000
+        movdqa  xmm0, xmmword ptr [rax]
+        mov     rax, rcx
+        add     rax, 16
+        movabs  rdx, offset __xmm@00000004000000040000000400000004
+        movdqa  xmm1, xmmword ptr [rdx]
+        movabs  rdx, offset __xmm@00000008000000080000000800000008
+        movdqa  xmm2, xmmword ptr [rdx]
+        mov     r9, r10
+        .p2align        4, 0x90
+.LBB0_4:
+        movdqa  xmm3, xmm0
+        paddd   xmm3, xmm1
+        movdqu  xmmword ptr [rax - 16], xmm0
+        movdqu  xmmword ptr [rax], xmm3
+        paddd   xmm0, xmm2
+        add     rax, 32
+        add     r9, -8
+        jne     .LBB0_4
+        cmp     r10, r8
+        je      .LBB0_7
+        .p2align        4, 0x90
+.LBB0_6:
+        mov     dword ptr [rcx + 4*r10], r10d
+        inc     r10
+        cmp     r8, r10
+        jne     .LBB0_6
+.LBB0_7:
+        sub     rsp, 32
+        movabs  rax, offset "DoSomethingWithLUT"
+        call    rax
+        nop
+        mov     rsp, rbp
+        pop     rbp
+        ret
+```
+
+The call to memset is now gone, because you've told Burst that any stack allocations within a method don't have to be initialized to zero. 
+

Library/PackageCache/com.unity.burst@1.8.4/Documentation~/projectMetadata.json

@@ -0,0 +1,3 @@
+{
+  "useMemberPages": true
+}