Repository: AnnulusGames/BurstLinq
Branch: main
Commit: fc354905c8e4
Files: 130
Total size: 632.0 KB

Directory structure:
gitextract_x5vozpec/

├── .gitattributes
├── .gitignore
├── Assets/
│   ├── BurstLinq/
│   │   ├── Runtime/
│   │   │   ├── BurstHelpers.cs
│   │   │   ├── BurstHelpers.cs.meta
│   │   │   ├── BurstLinq.asmdef
│   │   │   ├── BurstLinq.asmdef.meta
│   │   │   ├── BurstLinqExtensions.Average.cs
│   │   │   ├── BurstLinqExtensions.Average.cs.meta
│   │   │   ├── BurstLinqExtensions.Average.tt
│   │   │   ├── BurstLinqExtensions.Average.tt.meta
│   │   │   ├── BurstLinqExtensions.Contains.cs
│   │   │   ├── BurstLinqExtensions.Contains.cs.meta
│   │   │   ├── BurstLinqExtensions.Contains.tt
│   │   │   ├── BurstLinqExtensions.Contains.tt.meta
│   │   │   ├── BurstLinqExtensions.Max.cs
│   │   │   ├── BurstLinqExtensions.Max.cs.meta
│   │   │   ├── BurstLinqExtensions.Max.tt
│   │   │   ├── BurstLinqExtensions.Max.tt.meta
│   │   │   ├── BurstLinqExtensions.Min.cs
│   │   │   ├── BurstLinqExtensions.Min.cs.meta
│   │   │   ├── BurstLinqExtensions.Min.tt
│   │   │   ├── BurstLinqExtensions.Min.tt.meta
│   │   │   ├── BurstLinqExtensions.Native.Average.cs
│   │   │   ├── BurstLinqExtensions.Native.Average.cs.meta
│   │   │   ├── BurstLinqExtensions.Native.Average.tt
│   │   │   ├── BurstLinqExtensions.Native.Average.tt.meta
│   │   │   ├── BurstLinqExtensions.Native.Contains.cs
│   │   │   ├── BurstLinqExtensions.Native.Contains.cs.meta
│   │   │   ├── BurstLinqExtensions.Native.Contains.tt
│   │   │   ├── BurstLinqExtensions.Native.Contains.tt.meta
│   │   │   ├── BurstLinqExtensions.Native.Max.cs
│   │   │   ├── BurstLinqExtensions.Native.Max.cs.meta
│   │   │   ├── BurstLinqExtensions.Native.Max.tt
│   │   │   ├── BurstLinqExtensions.Native.Max.tt.meta
│   │   │   ├── BurstLinqExtensions.Native.Min.cs
│   │   │   ├── BurstLinqExtensions.Native.Min.cs.meta
│   │   │   ├── BurstLinqExtensions.Native.Min.tt
│   │   │   ├── BurstLinqExtensions.Native.Min.tt.meta
│   │   │   ├── BurstLinqExtensions.Native.SequenceEqual.cs
│   │   │   ├── BurstLinqExtensions.Native.SequenceEqual.cs.meta
│   │   │   ├── BurstLinqExtensions.Native.SequenceEqual.tt
│   │   │   ├── BurstLinqExtensions.Native.SequenceEqual.tt.meta
│   │   │   ├── BurstLinqExtensions.Native.Sum.cs
│   │   │   ├── BurstLinqExtensions.Native.Sum.cs.meta
│   │   │   ├── BurstLinqExtensions.Native.Sum.tt
│   │   │   ├── BurstLinqExtensions.Native.Sum.tt.meta
│   │   │   ├── BurstLinqExtensions.SequenceEqual.cs
│   │   │   ├── BurstLinqExtensions.SequenceEqual.cs.meta
│   │   │   ├── BurstLinqExtensions.SequenceEqual.tt
│   │   │   ├── BurstLinqExtensions.SequenceEqual.tt.meta
│   │   │   ├── BurstLinqExtensions.Sum.cs
│   │   │   ├── BurstLinqExtensions.Sum.cs.meta
│   │   │   ├── BurstLinqExtensions.Sum.tt
│   │   │   ├── BurstLinqExtensions.Sum.tt.meta
│   │   │   ├── BurstLinqExtensions.cs
│   │   │   ├── BurstLinqExtensions.cs.meta
│   │   │   ├── CmpHelpers.cs
│   │   │   ├── CmpHelpers.cs.meta
│   │   │   ├── Error.cs
│   │   │   ├── Error.cs.meta
│   │   │   ├── SpanHelper.cs
│   │   │   ├── SpanHelper.cs.meta
│   │   │   ├── Vectors.cs
│   │   │   └── Vectors.cs.meta
│   │   ├── Runtime.meta
│   │   ├── Tests/
│   │   │   ├── Runtime/
│   │   │   │   ├── AssertEx.cs
│   │   │   │   ├── AssertEx.cs.meta
│   │   │   │   ├── AverageTest.cs
│   │   │   │   ├── AverageTest.cs.meta
│   │   │   │   ├── AverageTest.tt
│   │   │   │   ├── AverageTest.tt.meta
│   │   │   │   ├── Benchmark.cs
│   │   │   │   ├── Benchmark.cs.meta
│   │   │   │   ├── BurstLinq.Tests.Runtime.asmdef
│   │   │   │   ├── BurstLinq.Tests.Runtime.asmdef.meta
│   │   │   │   ├── ContainsTest.cs
│   │   │   │   ├── ContainsTest.cs.meta
│   │   │   │   ├── MaxTest.cs
│   │   │   │   ├── MaxTest.cs.meta
│   │   │   │   ├── MaxTest.tt
│   │   │   │   ├── MaxTest.tt.meta
│   │   │   │   ├── MinTest.cs
│   │   │   │   ├── MinTest.cs.meta
│   │   │   │   ├── MinTest.tt
│   │   │   │   ├── MinTest.tt.meta
│   │   │   │   ├── RandomEnumerable.cs
│   │   │   │   ├── RandomEnumerable.cs.meta
│   │   │   │   ├── SequenceEqualTest.cs
│   │   │   │   ├── SequenceEqualTest.cs.meta
│   │   │   │   ├── SequenceEqualTest.tt
│   │   │   │   ├── SequenceEqualTest.tt.meta
│   │   │   │   ├── SumTest.cs
│   │   │   │   ├── SumTest.cs.meta
│   │   │   │   ├── SumTest.tt
│   │   │   │   └── SumTest.tt.meta
│   │   │   └── Runtime.meta
│   │   ├── Tests.meta
│   │   ├── package.json
│   │   └── package.json.meta
│   └── BurstLinq.meta
├── LICENSE
├── Packages/
│   ├── manifest.json
│   └── packages-lock.json
├── ProjectSettings/
│   ├── AudioManager.asset
│   ├── BurstAotSettings_StandaloneOSX.json
│   ├── ClusterInputManager.asset
│   ├── CommonBurstAotSettings.json
│   ├── DynamicsManager.asset
│   ├── EditorBuildSettings.asset
│   ├── EditorSettings.asset
│   ├── GraphicsSettings.asset
│   ├── InputManager.asset
│   ├── MemorySettings.asset
│   ├── NavMeshAreas.asset
│   ├── PackageManagerSettings.asset
│   ├── Packages/
│   │   └── com.unity.testtools.codecoverage/
│   │       └── Settings.json
│   ├── Physics2DSettings.asset
│   ├── PresetManager.asset
│   ├── ProjectSettings.asset
│   ├── ProjectVersion.txt
│   ├── QualitySettings.asset
│   ├── SceneTemplateSettings.json
│   ├── TagManager.asset
│   ├── TimeManager.asset
│   ├── UnityConnectSettings.asset
│   ├── VFXManager.asset
│   ├── VersionControlSettings.asset
│   └── XRSettings.asset
├── README.md
└── README_JA.md

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitattributes
================================================
# Auto detect text files and perform LF normalization
* text=auto


================================================
FILE: .gitignore
================================================
# This .gitignore file should be placed at the root of your Unity project directory
#
# Get latest from https://github.com/github/gitignore/blob/main/Unity.gitignore
#
/[Ll]ibrary/
/[Tt]emp/
/[Oo]bj/
/[Bb]uild/
/[Bb]uilds/
/[Ll]ogs/
/[Uu]ser[Ss]ettings/

# MemoryCaptures can get excessive in size.
# They also could contain extremely sensitive data
/[Mm]emoryCaptures/

# Recordings can get excessive in size
/[Rr]ecordings/

# Uncomment this line if you wish to ignore the asset store tools plugin
# /[Aa]ssets/AssetStoreTools*

# Autogenerated Jetbrains Rider plugin
/[Aa]ssets/Plugins/Editor/JetBrains*

# Visual Studio cache directory
.vs/

# Gradle cache directory
.gradle/

# Autogenerated VS/MD/Consulo solution and project files
ExportedObj/
.consulo/
*.csproj
*.unityproj
*.sln
*.suo
*.tmp
*.user
*.userprefs
*.pidb
*.booproj
*.svd
*.pdb
*.mdb
*.opendb
*.VC.db

# Unity3D generated meta files
*.pidb.meta
*.pdb.meta
*.mdb.meta

# Unity3D generated file on crash reports
sysinfo.txt

# Builds
*.apk
*.aab
*.unitypackage
*.app

# Crashlytics generated file
crashlytics-build.properties

# Packed Addressables
/[Aa]ssets/[Aa]ddressable[Aa]ssets[Dd]ata/*/*.bin*

# Temporary auto-generated Android Assets
/[Aa]ssets/[Ss]treamingAssets/aa.meta
/[Aa]ssets/[Ss]treamingAssets/aa/*

# Visual Studio Code cache directory
.vscode/

# DS_Store
*.DS_Store

================================================
FILE: Assets/BurstLinq/Runtime/BurstHelpers.cs
================================================
using Unity.Burst.Intrinsics;

namespace BurstLinq
{
    internal static unsafe class BurstHelpers
    {
        internal static bool IsFloatingPoint256Supported => X86.Avx.IsAvxSupported;
        internal static bool IsInteger256Supported => X86.Avx2.IsAvx2Supported;
        internal static bool IsV256Supported => X86.Avx2.IsAvx2Supported;
        internal static bool IsV128Supported => Arm.Neon.IsNeonSupported||X86.Sse4_1.IsSse41Supported;
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstHelpers.cs.meta
================================================
fileFormatVersion: 2
guid: 617908ec85574495e82cbe33f5fa3c3a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinq.asmdef
================================================
{
    "name": "BurstLinq",
    "rootNamespace": "BurstLinq",
    "references": [
        "GUID:e0cd26848372d4e5c891c569017e11f1",
        "GUID:2665a8d13d1b3f18800f46e256720795",
        "GUID:d8b63aba1907145bea998dd612889d6b"
    ],
    "includePlatforms": [],
    "excludePlatforms": [],
    "allowUnsafeCode": true,
    "overrideReferences": false,
    "precompiledReferences": [],
    "autoReferenced": true,
    "defineConstraints": [],
    "versionDefines": [],
    "noEngineReferences": false
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinq.asmdef.meta
================================================
fileFormatVersion: 2
guid: 75a4edf3e29b24eacad77b2b175d4d8f
AssemblyDefinitionImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Average.cs
================================================
using System;
using System.Collections.Generic;
using Unity.Collections;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static double Average(this int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (int* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Average(this List<int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Average(this Memory<int> source)
        {
            return Average((ReadOnlySpan<int>)source.Span);
        }

        public static double Average(this ReadOnlyMemory<int> source)
        {
            return Average(source.Span);
        }

        public static double Average(this Span<int> source)
        {
            return Average((ReadOnlySpan<int>)source);
        }

        public static double Average(this ReadOnlySpan<int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (int* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Average(this uint[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (uint* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Average(this List<uint> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Average(this Memory<uint> source)
        {
            return Average((ReadOnlySpan<uint>)source.Span);
        }

        public static double Average(this ReadOnlyMemory<uint> source)
        {
            return Average(source.Span);
        }

        public static double Average(this Span<uint> source)
        {
            return Average((ReadOnlySpan<uint>)source);
        }

        public static double Average(this ReadOnlySpan<uint> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (uint* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Average(this long[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (long* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Average(this List<long> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (long* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Average(this Memory<long> source)
        {
            return Average((ReadOnlySpan<long>)source.Span);
        }

        public static double Average(this ReadOnlyMemory<long> source)
        {
            return Average(source.Span);
        }

        public static double Average(this Span<long> source)
        {
            return Average((ReadOnlySpan<long>)source);
        }

        public static double Average(this ReadOnlySpan<long> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (long* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Average(this ulong[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (ulong* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Average(this List<ulong> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (ulong* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Average(this Memory<ulong> source)
        {
            return Average((ReadOnlySpan<ulong>)source.Span);
        }

        public static double Average(this ReadOnlyMemory<ulong> source)
        {
            return Average(source.Span);
        }

        public static double Average(this Span<ulong> source)
        {
            return Average((ReadOnlySpan<ulong>)source);
        }

        public static double Average(this ReadOnlySpan<ulong> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (ulong* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float Average(this float[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (float* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float Average(this List<float> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float Average(this Memory<float> source)
        {
            return Average((ReadOnlySpan<float>)source.Span);
        }

        public static float Average(this ReadOnlyMemory<float> source)
        {
            return Average(source.Span);
        }

        public static float Average(this Span<float> source)
        {
            return Average((ReadOnlySpan<float>)source);
        }

        public static float Average(this ReadOnlySpan<float> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (float* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Average(this double[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (double* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Average(this List<double> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Average(this Memory<double> source)
        {
            return Average((ReadOnlySpan<double>)source.Span);
        }

        public static double Average(this ReadOnlyMemory<double> source)
        {
            return Average(source.Span);
        }

        public static double Average(this Span<double> source)
        {
            return Average((ReadOnlySpan<double>)source);
        }

        public static double Average(this ReadOnlySpan<double> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (double* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector2 Average(this Vector2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (Vector2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector2 Average(this List<Vector2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector2* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector2 Average(this Memory<Vector2> source)
        {
            return Average((ReadOnlySpan<Vector2>)source.Span);
        }

        public static Vector2 Average(this ReadOnlyMemory<Vector2> source)
        {
            return Average(source.Span);
        }

        public static Vector2 Average(this Span<Vector2> source)
        {
            return Average((ReadOnlySpan<Vector2>)source);
        }

        public static Vector2 Average(this ReadOnlySpan<Vector2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (Vector2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector2 Average(this Vector2Int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (Vector2Int* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector2 Average(this List<Vector2Int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector2Int* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector2 Average(this Memory<Vector2Int> source)
        {
            return Average((ReadOnlySpan<Vector2Int>)source.Span);
        }

        public static Vector2 Average(this ReadOnlyMemory<Vector2Int> source)
        {
            return Average(source.Span);
        }

        public static Vector2 Average(this Span<Vector2Int> source)
        {
            return Average((ReadOnlySpan<Vector2Int>)source);
        }

        public static Vector2 Average(this ReadOnlySpan<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (Vector2Int* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector3 Average(this Vector3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (Vector3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector3 Average(this List<Vector3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector3* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector3 Average(this Memory<Vector3> source)
        {
            return Average((ReadOnlySpan<Vector3>)source.Span);
        }

        public static Vector3 Average(this ReadOnlyMemory<Vector3> source)
        {
            return Average(source.Span);
        }

        public static Vector3 Average(this Span<Vector3> source)
        {
            return Average((ReadOnlySpan<Vector3>)source);
        }

        public static Vector3 Average(this ReadOnlySpan<Vector3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (Vector3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector3 Average(this Vector3Int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (Vector3Int* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector3 Average(this List<Vector3Int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector3Int* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector3 Average(this Memory<Vector3Int> source)
        {
            return Average((ReadOnlySpan<Vector3Int>)source.Span);
        }

        public static Vector3 Average(this ReadOnlyMemory<Vector3Int> source)
        {
            return Average(source.Span);
        }

        public static Vector3 Average(this Span<Vector3Int> source)
        {
            return Average((ReadOnlySpan<Vector3Int>)source);
        }

        public static Vector3 Average(this ReadOnlySpan<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (Vector3Int* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector4 Average(this Vector4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (Vector4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector4 Average(this List<Vector4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector4* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector4 Average(this Memory<Vector4> source)
        {
            return Average((ReadOnlySpan<Vector4>)source.Span);
        }

        public static Vector4 Average(this ReadOnlyMemory<Vector4> source)
        {
            return Average(source.Span);
        }

        public static Vector4 Average(this Span<Vector4> source)
        {
            return Average((ReadOnlySpan<Vector4>)source);
        }

        public static Vector4 Average(this ReadOnlySpan<Vector4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (Vector4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double2 Average(this int2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (int2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double2 Average(this List<int2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int2* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double2 Average(this Memory<int2> source)
        {
            return Average((ReadOnlySpan<int2>)source.Span);
        }

        public static double2 Average(this ReadOnlyMemory<int2> source)
        {
            return Average(source.Span);
        }

        public static double2 Average(this Span<int2> source)
        {
            return Average((ReadOnlySpan<int2>)source);
        }

        public static double2 Average(this ReadOnlySpan<int2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (int2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double3 Average(this int3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (int3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double3 Average(this List<int3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int3* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double3 Average(this Memory<int3> source)
        {
            return Average((ReadOnlySpan<int3>)source.Span);
        }

        public static double3 Average(this ReadOnlyMemory<int3> source)
        {
            return Average(source.Span);
        }

        public static double3 Average(this Span<int3> source)
        {
            return Average((ReadOnlySpan<int3>)source);
        }

        public static double3 Average(this ReadOnlySpan<int3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (int3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double4 Average(this int4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (int4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double4 Average(this List<int4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int4* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double4 Average(this Memory<int4> source)
        {
            return Average((ReadOnlySpan<int4>)source.Span);
        }

        public static double4 Average(this ReadOnlyMemory<int4> source)
        {
            return Average(source.Span);
        }

        public static double4 Average(this Span<int4> source)
        {
            return Average((ReadOnlySpan<int4>)source);
        }

        public static double4 Average(this ReadOnlySpan<int4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (int4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float2 Average(this float2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (float2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float2 Average(this List<float2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float2* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float2 Average(this Memory<float2> source)
        {
            return Average((ReadOnlySpan<float2>)source.Span);
        }

        public static float2 Average(this ReadOnlyMemory<float2> source)
        {
            return Average(source.Span);
        }

        public static float2 Average(this Span<float2> source)
        {
            return Average((ReadOnlySpan<float2>)source);
        }

        public static float2 Average(this ReadOnlySpan<float2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (float2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float3 Average(this float3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (float3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float3 Average(this List<float3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float3* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float3 Average(this Memory<float3> source)
        {
            return Average((ReadOnlySpan<float3>)source.Span);
        }

        public static float3 Average(this ReadOnlyMemory<float3> source)
        {
            return Average(source.Span);
        }

        public static float3 Average(this Span<float3> source)
        {
            return Average((ReadOnlySpan<float3>)source);
        }

        public static float3 Average(this ReadOnlySpan<float3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (float3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float4 Average(this float4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (float4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float4 Average(this List<float4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float4* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float4 Average(this Memory<float4> source)
        {
            return Average((ReadOnlySpan<float4>)source.Span);
        }

        public static float4 Average(this ReadOnlyMemory<float4> source)
        {
            return Average(source.Span);
        }

        public static float4 Average(this Span<float4> source)
        {
            return Average((ReadOnlySpan<float4>)source);
        }

        public static float4 Average(this ReadOnlySpan<float4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (float4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double2 Average(this double2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (double2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double2 Average(this List<double2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double2* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double2 Average(this Memory<double2> source)
        {
            return Average((ReadOnlySpan<double2>)source.Span);
        }

        public static double2 Average(this ReadOnlyMemory<double2> source)
        {
            return Average(source.Span);
        }

        public static double2 Average(this Span<double2> source)
        {
            return Average((ReadOnlySpan<double2>)source);
        }

        public static double2 Average(this ReadOnlySpan<double2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (double2* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double3 Average(this double3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (double3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double3 Average(this List<double3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double3* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double3 Average(this Memory<double3> source)
        {
            return Average((ReadOnlySpan<double3>)source.Span);
        }

        public static double3 Average(this ReadOnlyMemory<double3> source)
        {
            return Average(source.Span);
        }

        public static double3 Average(this Span<double3> source)
        {
            return Average((ReadOnlySpan<double3>)source);
        }

        public static double3 Average(this ReadOnlySpan<double3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (double3* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double4 Average(this double4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (double4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double4 Average(this List<double4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double4* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double4 Average(this Memory<double4> source)
        {
            return Average((ReadOnlySpan<double4>)source.Span);
        }

        public static double4 Average(this ReadOnlyMemory<double4> source)
        {
            return Average(source.Span);
        }

        public static double4 Average(this Span<double4> source)
        {
            return Average((ReadOnlySpan<double4>)source);
        }

        public static double4 Average(this ReadOnlySpan<double4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (double4* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Average.cs.meta
================================================
fileFormatVersion: 2
guid: 78fa11b0b39df45cf92985561e609461
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Average.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
    
    System.Func<string, string> retType = (string x) => 
    {
        switch (x)
        {
            default: return "double";
            case "float": return "float";
            case "Vector2":
            case "Vector2Int": return "Vector2";
            case "Vector3":
            case "Vector3Int": return "Vector3";
            case "Vector4": return "Vector4";
            case "float2": return "float2";
            case "float3": return "float3";
            case "float4": return "float4";
            case "int2":
            case "double2": return "double2";
            case "int3":
            case "double3": return "double3";
            case "int4":
            case "double4": return "double4";
        }
        return "";
    };
#>
using System;
using System.Collections.Generic;
using Unity.Collections;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=retType(type)#> Average(this <#=type#>[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            
            fixed (<#=type#>* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static <#=retType(type)#> Average(this List<<#=type#>> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (<#=type#>* ptr = span)
            {
                AverageCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static <#=retType(type)#> Average(this Memory<<#=type#>> source)
        {
            return Average((ReadOnlySpan<<#=type#>>)source.Span);
        }

        public static <#=retType(type)#> Average(this ReadOnlyMemory<<#=type#>> source)
        {
            return Average(source.Span);
        }

        public static <#=retType(type)#>  Average(this Span<<#=type#>> source)
        {
            return Average((ReadOnlySpan<<#=type#>>)source);
        }

        public static <#=retType(type)#>  Average(this ReadOnlySpan<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);

            fixed (<#=type#>* ptr = source)
            {
                AverageCore(ptr, source.Length, out var result);
                return result;
            }
        }
<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Average.tt.meta
================================================
fileFormatVersion: 2
guid: 21e144b8b72bb4e0f842d711c313d4c4
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Contains.cs
================================================
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static bool Contains(this byte[] source, byte value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (byte* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<byte> source, byte value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (byte* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<byte> source, byte value)
        {
            return Contains((ReadOnlySpan<byte>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<byte> source, byte value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<byte> source, byte value)
        {
            return Contains((ReadOnlySpan<byte>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<byte> source, byte value)
        {
            if (source.IsEmpty) return false;

            fixed (byte* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this sbyte[] source, sbyte value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (sbyte* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<sbyte> source, sbyte value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (sbyte* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<sbyte> source, sbyte value)
        {
            return Contains((ReadOnlySpan<sbyte>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<sbyte> source, sbyte value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<sbyte> source, sbyte value)
        {
            return Contains((ReadOnlySpan<sbyte>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<sbyte> source, sbyte value)
        {
            if (source.IsEmpty) return false;

            fixed (sbyte* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this short[] source, short value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (short* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<short> source, short value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (short* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<short> source, short value)
        {
            return Contains((ReadOnlySpan<short>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<short> source, short value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<short> source, short value)
        {
            return Contains((ReadOnlySpan<short>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<short> source, short value)
        {
            if (source.IsEmpty) return false;

            fixed (short* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this ushort[] source, ushort value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (ushort* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<ushort> source, ushort value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (ushort* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<ushort> source, ushort value)
        {
            return Contains((ReadOnlySpan<ushort>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<ushort> source, ushort value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<ushort> source, ushort value)
        {
            return Contains((ReadOnlySpan<ushort>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<ushort> source, ushort value)
        {
            if (source.IsEmpty) return false;

            fixed (ushort* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this int[] source, int value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (int* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<int> source, int value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (int* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<int> source, int value)
        {
            return Contains((ReadOnlySpan<int>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<int> source, int value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<int> source, int value)
        {
            return Contains((ReadOnlySpan<int>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<int> source, int value)
        {
            if (source.IsEmpty) return false;

            fixed (int* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this uint[] source, uint value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (uint* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<uint> source, uint value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (uint* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<uint> source, uint value)
        {
            return Contains((ReadOnlySpan<uint>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<uint> source, uint value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<uint> source, uint value)
        {
            return Contains((ReadOnlySpan<uint>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<uint> source, uint value)
        {
            if (source.IsEmpty) return false;

            fixed (uint* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this long[] source, long value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (long* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<long> source, long value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (long* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<long> source, long value)
        {
            return Contains((ReadOnlySpan<long>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<long> source, long value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<long> source, long value)
        {
            return Contains((ReadOnlySpan<long>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<long> source, long value)
        {
            if (source.IsEmpty) return false;

            fixed (long* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this ulong[] source, ulong value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (ulong* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<ulong> source, ulong value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (ulong* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<ulong> source, ulong value)
        {
            return Contains((ReadOnlySpan<ulong>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<ulong> source, ulong value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<ulong> source, ulong value)
        {
            return Contains((ReadOnlySpan<ulong>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<ulong> source, ulong value)
        {
            if (source.IsEmpty) return false;

            fixed (ulong* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this float[] source, float value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (float* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<float> source, float value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (float* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<float> source, float value)
        {
            return Contains((ReadOnlySpan<float>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<float> source, float value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<float> source, float value)
        {
            return Contains((ReadOnlySpan<float>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<float> source, float value)
        {
            if (source.IsEmpty) return false;

            fixed (float* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this double[] source, double value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (double* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<double> source, double value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (double* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<double> source, double value)
        {
            return Contains((ReadOnlySpan<double>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<double> source, double value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<double> source, double value)
        {
            return Contains((ReadOnlySpan<double>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<double> source, double value)
        {
            if (source.IsEmpty) return false;

            fixed (double* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this Vector2[] source, Vector2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (Vector2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<Vector2> source, Vector2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (Vector2* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<Vector2> source, Vector2 value)
        {
            return Contains((ReadOnlySpan<Vector2>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<Vector2> source, Vector2 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<Vector2> source, Vector2 value)
        {
            return Contains((ReadOnlySpan<Vector2>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<Vector2> source, Vector2 value)
        {
            if (source.IsEmpty) return false;

            fixed (Vector2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this Vector2Int[] source, Vector2Int value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (Vector2Int* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<Vector2Int> source, Vector2Int value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (Vector2Int* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<Vector2Int> source, Vector2Int value)
        {
            return Contains((ReadOnlySpan<Vector2Int>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<Vector2Int> source, Vector2Int value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<Vector2Int> source, Vector2Int value)
        {
            return Contains((ReadOnlySpan<Vector2Int>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<Vector2Int> source, Vector2Int value)
        {
            if (source.IsEmpty) return false;

            fixed (Vector2Int* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this Vector3[] source, Vector3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (Vector3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<Vector3> source, Vector3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (Vector3* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<Vector3> source, Vector3 value)
        {
            return Contains((ReadOnlySpan<Vector3>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<Vector3> source, Vector3 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<Vector3> source, Vector3 value)
        {
            return Contains((ReadOnlySpan<Vector3>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<Vector3> source, Vector3 value)
        {
            if (source.IsEmpty) return false;

            fixed (Vector3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this Vector3Int[] source, Vector3Int value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (Vector3Int* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<Vector3Int> source, Vector3Int value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (Vector3Int* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<Vector3Int> source, Vector3Int value)
        {
            return Contains((ReadOnlySpan<Vector3Int>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<Vector3Int> source, Vector3Int value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<Vector3Int> source, Vector3Int value)
        {
            return Contains((ReadOnlySpan<Vector3Int>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<Vector3Int> source, Vector3Int value)
        {
            if (source.IsEmpty) return false;

            fixed (Vector3Int* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this Vector4[] source, Vector4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (Vector4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<Vector4> source, Vector4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (Vector4* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<Vector4> source, Vector4 value)
        {
            return Contains((ReadOnlySpan<Vector4>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<Vector4> source, Vector4 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<Vector4> source, Vector4 value)
        {
            return Contains((ReadOnlySpan<Vector4>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<Vector4> source, Vector4 value)
        {
            if (source.IsEmpty) return false;

            fixed (Vector4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this int2[] source, int2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (int2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<int2> source, int2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (int2* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<int2> source, int2 value)
        {
            return Contains((ReadOnlySpan<int2>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<int2> source, int2 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<int2> source, int2 value)
        {
            return Contains((ReadOnlySpan<int2>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<int2> source, int2 value)
        {
            if (source.IsEmpty) return false;

            fixed (int2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this int3[] source, int3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (int3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<int3> source, int3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (int3* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<int3> source, int3 value)
        {
            return Contains((ReadOnlySpan<int3>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<int3> source, int3 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<int3> source, int3 value)
        {
            return Contains((ReadOnlySpan<int3>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<int3> source, int3 value)
        {
            if (source.IsEmpty) return false;

            fixed (int3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this int4[] source, int4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (int4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<int4> source, int4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (int4* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<int4> source, int4 value)
        {
            return Contains((ReadOnlySpan<int4>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<int4> source, int4 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<int4> source, int4 value)
        {
            return Contains((ReadOnlySpan<int4>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<int4> source, int4 value)
        {
            if (source.IsEmpty) return false;

            fixed (int4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this uint2[] source, uint2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (uint2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<uint2> source, uint2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (uint2* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<uint2> source, uint2 value)
        {
            return Contains((ReadOnlySpan<uint2>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<uint2> source, uint2 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<uint2> source, uint2 value)
        {
            return Contains((ReadOnlySpan<uint2>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<uint2> source, uint2 value)
        {
            if (source.IsEmpty) return false;

            fixed (uint2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this uint3[] source, uint3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (uint3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<uint3> source, uint3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (uint3* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<uint3> source, uint3 value)
        {
            return Contains((ReadOnlySpan<uint3>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<uint3> source, uint3 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<uint3> source, uint3 value)
        {
            return Contains((ReadOnlySpan<uint3>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<uint3> source, uint3 value)
        {
            if (source.IsEmpty) return false;

            fixed (uint3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this uint4[] source, uint4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (uint4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<uint4> source, uint4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (uint4* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<uint4> source, uint4 value)
        {
            return Contains((ReadOnlySpan<uint4>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<uint4> source, uint4 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<uint4> source, uint4 value)
        {
            return Contains((ReadOnlySpan<uint4>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<uint4> source, uint4 value)
        {
            if (source.IsEmpty) return false;

            fixed (uint4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this float2[] source, float2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (float2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<float2> source, float2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (float2* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<float2> source, float2 value)
        {
            return Contains((ReadOnlySpan<float2>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<float2> source, float2 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<float2> source, float2 value)
        {
            return Contains((ReadOnlySpan<float2>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<float2> source, float2 value)
        {
            if (source.IsEmpty) return false;

            fixed (float2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this float3[] source, float3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (float3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<float3> source, float3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (float3* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<float3> source, float3 value)
        {
            return Contains((ReadOnlySpan<float3>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<float3> source, float3 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<float3> source, float3 value)
        {
            return Contains((ReadOnlySpan<float3>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<float3> source, float3 value)
        {
            if (source.IsEmpty) return false;

            fixed (float3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this float4[] source, float4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (float4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<float4> source, float4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (float4* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<float4> source, float4 value)
        {
            return Contains((ReadOnlySpan<float4>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<float4> source, float4 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<float4> source, float4 value)
        {
            return Contains((ReadOnlySpan<float4>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<float4> source, float4 value)
        {
            if (source.IsEmpty) return false;

            fixed (float4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this double2[] source, double2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (double2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<double2> source, double2 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (double2* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<double2> source, double2 value)
        {
            return Contains((ReadOnlySpan<double2>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<double2> source, double2 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<double2> source, double2 value)
        {
            return Contains((ReadOnlySpan<double2>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<double2> source, double2 value)
        {
            if (source.IsEmpty) return false;

            fixed (double2* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this double3[] source, double3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (double3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<double3> source, double3 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (double3* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<double3> source, double3 value)
        {
            return Contains((ReadOnlySpan<double3>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<double3> source, double3 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<double3> source, double3 value)
        {
            return Contains((ReadOnlySpan<double3>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<double3> source, double3 value)
        {
            if (source.IsEmpty) return false;

            fixed (double3* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
        public static bool Contains(this double4[] source, double4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (double4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<double4> source, double4 value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (double4* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<double4> source, double4 value)
        {
            return Contains((ReadOnlySpan<double4>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<double4> source, double4 value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<double4> source, double4 value)
        {
            return Contains((ReadOnlySpan<double4>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<double4> source, double4 value)
        {
            if (source.IsEmpty) return false;

            fixed (double4* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Contains.cs.meta
================================================
fileFormatVersion: 2
guid: d9eb388d44f6c4009b8413bbef734ae2
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Contains.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
#>
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static bool Contains(this <#=type#>[] source, <#=type#> value)
        {
            Error.ThrowIfNull(source);
            if (source.Length == 0) return false;

            fixed (<#=type#>* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }

        public static bool Contains(this List<<#=type#>> source, <#=type#> value)
        {
            Error.ThrowIfNull(source);
            if (source.Count == 0) return false;

            var span = SpanHelper.AsSpan(source);
            fixed (<#=type#>* ptr = span)
            {
                return ContainsCore(ptr, source.Count, value);
            }
        }

        public static bool Contains(this Memory<<#=type#>> source, <#=type#> value)
        {
            return Contains((ReadOnlySpan<<#=type#>>)source.Span, value);
        }

        public static bool Contains(this ReadOnlyMemory<<#=type#>> source, <#=type#> value)
        {
            return Contains(source.Span, value);
        }

        public static bool Contains(this Span<<#=type#>> source, <#=type#> value)
        {
            return Contains((ReadOnlySpan<<#=type#>>)source, value);
        }

        public static bool Contains(this ReadOnlySpan<<#=type#>> source, <#=type#> value)
        {
            if (source.IsEmpty) return false;

            fixed (<#=type#>* ptr = source)
            {
                return ContainsCore(ptr, source.Length, value);
            }
        }
<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Contains.tt.meta
================================================
fileFormatVersion: 2
guid: 09d9091d25ab146cd83aa6bd009f5fb9
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Max.cs
================================================
using System;
using System.Collections.Generic;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static byte Max(this byte[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (byte* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static byte Max(this List<byte> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (byte* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static byte Max(this Memory<byte> source)
        {
            return Max((ReadOnlySpan<byte>)source.Span);
        }

        public static byte Max(this ReadOnlyMemory<byte> source)
        {
            return Max(source.Span);
        }

        public static byte Max(this Span<byte> source)
        {
            return Max((ReadOnlySpan<byte>)source);
        }

        public static byte Max(this ReadOnlySpan<byte> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (byte* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static sbyte Max(this sbyte[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (sbyte* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static sbyte Max(this List<sbyte> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (sbyte* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static sbyte Max(this Memory<sbyte> source)
        {
            return Max((ReadOnlySpan<sbyte>)source.Span);
        }

        public static sbyte Max(this ReadOnlyMemory<sbyte> source)
        {
            return Max(source.Span);
        }

        public static sbyte Max(this Span<sbyte> source)
        {
            return Max((ReadOnlySpan<sbyte>)source);
        }

        public static sbyte Max(this ReadOnlySpan<sbyte> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (sbyte* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static short Max(this short[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (short* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static short Max(this List<short> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (short* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static short Max(this Memory<short> source)
        {
            return Max((ReadOnlySpan<short>)source.Span);
        }

        public static short Max(this ReadOnlyMemory<short> source)
        {
            return Max(source.Span);
        }

        public static short Max(this Span<short> source)
        {
            return Max((ReadOnlySpan<short>)source);
        }

        public static short Max(this ReadOnlySpan<short> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (short* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static ushort Max(this ushort[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (ushort* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static ushort Max(this List<ushort> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (ushort* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static ushort Max(this Memory<ushort> source)
        {
            return Max((ReadOnlySpan<ushort>)source.Span);
        }

        public static ushort Max(this ReadOnlyMemory<ushort> source)
        {
            return Max(source.Span);
        }

        public static ushort Max(this Span<ushort> source)
        {
            return Max((ReadOnlySpan<ushort>)source);
        }

        public static ushort Max(this ReadOnlySpan<ushort> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (ushort* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static int Max(this int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (int* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static int Max(this List<int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static int Max(this Memory<int> source)
        {
            return Max((ReadOnlySpan<int>)source.Span);
        }

        public static int Max(this ReadOnlyMemory<int> source)
        {
            return Max(source.Span);
        }

        public static int Max(this Span<int> source)
        {
            return Max((ReadOnlySpan<int>)source);
        }

        public static int Max(this ReadOnlySpan<int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (int* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static uint Max(this uint[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (uint* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static uint Max(this List<uint> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static uint Max(this Memory<uint> source)
        {
            return Max((ReadOnlySpan<uint>)source.Span);
        }

        public static uint Max(this ReadOnlyMemory<uint> source)
        {
            return Max(source.Span);
        }

        public static uint Max(this Span<uint> source)
        {
            return Max((ReadOnlySpan<uint>)source);
        }

        public static uint Max(this ReadOnlySpan<uint> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (uint* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static long Max(this long[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (long* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static long Max(this List<long> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (long* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static long Max(this Memory<long> source)
        {
            return Max((ReadOnlySpan<long>)source.Span);
        }

        public static long Max(this ReadOnlyMemory<long> source)
        {
            return Max(source.Span);
        }

        public static long Max(this Span<long> source)
        {
            return Max((ReadOnlySpan<long>)source);
        }

        public static long Max(this ReadOnlySpan<long> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (long* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static ulong Max(this ulong[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (ulong* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static ulong Max(this List<ulong> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (ulong* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static ulong Max(this Memory<ulong> source)
        {
            return Max((ReadOnlySpan<ulong>)source.Span);
        }

        public static ulong Max(this ReadOnlyMemory<ulong> source)
        {
            return Max(source.Span);
        }

        public static ulong Max(this Span<ulong> source)
        {
            return Max((ReadOnlySpan<ulong>)source);
        }

        public static ulong Max(this ReadOnlySpan<ulong> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (ulong* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float Max(this float[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (float* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float Max(this List<float> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float Max(this Memory<float> source)
        {
            return Max((ReadOnlySpan<float>)source.Span);
        }

        public static float Max(this ReadOnlyMemory<float> source)
        {
            return Max(source.Span);
        }

        public static float Max(this Span<float> source)
        {
            return Max((ReadOnlySpan<float>)source);
        }

        public static float Max(this ReadOnlySpan<float> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (float* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Max(this double[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (double* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Max(this List<double> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Max(this Memory<double> source)
        {
            return Max((ReadOnlySpan<double>)source.Span);
        }

        public static double Max(this ReadOnlyMemory<double> source)
        {
            return Max(source.Span);
        }

        public static double Max(this Span<double> source)
        {
            return Max((ReadOnlySpan<double>)source);
        }

        public static double Max(this ReadOnlySpan<double> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (double* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Max.cs.meta
================================================
fileFormatVersion: 2
guid: b45de311116c143618fe3131431441f3
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Max.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double"
    };
#>
using System;
using System.Collections.Generic;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=type#> Max(this <#=type#>[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            
            fixed (<#=type#>* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static <#=type#> Max(this List<<#=type#>> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);
            
            var span = SpanHelper.AsSpan(source);
            fixed (<#=type#>* ptr = span)
            {
                MaxCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static <#=type#> Max(this Memory<<#=type#>> source)
        {
            return Max((ReadOnlySpan<<#=type#>>)source.Span);
        }

        public static <#=type#> Max(this ReadOnlyMemory<<#=type#>> source)
        {
            return Max(source.Span);
        }

        public static <#=type#> Max(this Span<<#=type#>> source)
        {
            return Max((ReadOnlySpan<<#=type#>>)source);
        }

        public static <#=type#> Max(this ReadOnlySpan<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (<#=type#>* ptr = source)
            {
                MaxCore(ptr, source.Length, out var result);
                return result;
            }
        }
<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Max.tt.meta
================================================
fileFormatVersion: 2
guid: 689524d35dd334b42bdcb35388d0cd48
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Min.cs
================================================
using System;
using System.Collections.Generic;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static byte Min(this byte[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (byte* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static byte Min(this List<byte> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (byte* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static byte Min(this Memory<byte> source)
        {
            return Min((ReadOnlySpan<byte>)source.Span);
        }

        public static byte Min(this ReadOnlyMemory<byte> source)
        {
            return Min(source.Span);
        }

        public static byte Min(this Span<byte> source)
        {
            return Min((ReadOnlySpan<byte>)source);
        }

        public static byte Min(this ReadOnlySpan<byte> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (byte* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static sbyte Min(this sbyte[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (sbyte* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static sbyte Min(this List<sbyte> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (sbyte* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static sbyte Min(this Memory<sbyte> source)
        {
            return Min((ReadOnlySpan<sbyte>)source.Span);
        }

        public static sbyte Min(this ReadOnlyMemory<sbyte> source)
        {
            return Min(source.Span);
        }

        public static sbyte Min(this Span<sbyte> source)
        {
            return Min((ReadOnlySpan<sbyte>)source);
        }

        public static sbyte Min(this ReadOnlySpan<sbyte> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (sbyte* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static short Min(this short[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (short* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static short Min(this List<short> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (short* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static short Min(this Memory<short> source)
        {
            return Min((ReadOnlySpan<short>)source.Span);
        }

        public static short Min(this ReadOnlyMemory<short> source)
        {
            return Min(source.Span);
        }

        public static short Min(this Span<short> source)
        {
            return Min((ReadOnlySpan<short>)source);
        }

        public static short Min(this ReadOnlySpan<short> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (short* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static ushort Min(this ushort[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (ushort* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static ushort Min(this List<ushort> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (ushort* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static ushort Min(this Memory<ushort> source)
        {
            return Min((ReadOnlySpan<ushort>)source.Span);
        }

        public static ushort Min(this ReadOnlyMemory<ushort> source)
        {
            return Min(source.Span);
        }

        public static ushort Min(this Span<ushort> source)
        {
            return Min((ReadOnlySpan<ushort>)source);
        }

        public static ushort Min(this ReadOnlySpan<ushort> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (ushort* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static int Min(this int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (int* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static int Min(this List<int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static int Min(this Memory<int> source)
        {
            return Min((ReadOnlySpan<int>)source.Span);
        }

        public static int Min(this ReadOnlyMemory<int> source)
        {
            return Min(source.Span);
        }

        public static int Min(this Span<int> source)
        {
            return Min((ReadOnlySpan<int>)source);
        }

        public static int Min(this ReadOnlySpan<int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (int* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static uint Min(this uint[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (uint* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static uint Min(this List<uint> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static uint Min(this Memory<uint> source)
        {
            return Min((ReadOnlySpan<uint>)source.Span);
        }

        public static uint Min(this ReadOnlyMemory<uint> source)
        {
            return Min(source.Span);
        }

        public static uint Min(this Span<uint> source)
        {
            return Min((ReadOnlySpan<uint>)source);
        }

        public static uint Min(this ReadOnlySpan<uint> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (uint* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static long Min(this long[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (long* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static long Min(this List<long> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (long* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static long Min(this Memory<long> source)
        {
            return Min((ReadOnlySpan<long>)source.Span);
        }

        public static long Min(this ReadOnlyMemory<long> source)
        {
            return Min(source.Span);
        }

        public static long Min(this Span<long> source)
        {
            return Min((ReadOnlySpan<long>)source);
        }

        public static long Min(this ReadOnlySpan<long> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (long* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static ulong Min(this ulong[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (ulong* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static ulong Min(this List<ulong> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (ulong* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static ulong Min(this Memory<ulong> source)
        {
            return Min((ReadOnlySpan<ulong>)source.Span);
        }

        public static ulong Min(this ReadOnlyMemory<ulong> source)
        {
            return Min(source.Span);
        }

        public static ulong Min(this Span<ulong> source)
        {
            return Min((ReadOnlySpan<ulong>)source);
        }

        public static ulong Min(this ReadOnlySpan<ulong> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (ulong* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float Min(this float[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (float* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float Min(this List<float> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float Min(this Memory<float> source)
        {
            return Min((ReadOnlySpan<float>)source.Span);
        }

        public static float Min(this ReadOnlyMemory<float> source)
        {
            return Min(source.Span);
        }

        public static float Min(this Span<float> source)
        {
            return Min((ReadOnlySpan<float>)source);
        }

        public static float Min(this ReadOnlySpan<float> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (float* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Min(this double[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);

            fixed (double* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Min(this List<double> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Min(this Memory<double> source)
        {
            return Min((ReadOnlySpan<double>)source.Span);
        }

        public static double Min(this ReadOnlyMemory<double> source)
        {
            return Min(source.Span);
        }

        public static double Min(this Span<double> source)
        {
            return Min((ReadOnlySpan<double>)source);
        }

        public static double Min(this ReadOnlySpan<double> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (double* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Min.cs.meta
================================================
fileFormatVersion: 2
guid: fd1e1e3cb6ec34036bcba189c14dce1a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Min.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double"
    };
#>
using System;
using System.Collections.Generic;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=type#> Min(this <#=type#>[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            
            fixed (<#=type#>* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static <#=type#> Min(this List<<#=type#>> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);
            
            var span = SpanHelper.AsSpan(source);
            fixed (<#=type#>* ptr = span)
            {
                MinCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static <#=type#> Min(this Memory<<#=type#>> source)
        {
            return Min((ReadOnlySpan<<#=type#>>)source.Span);
        }

        public static <#=type#> Min(this ReadOnlyMemory<<#=type#>> source)
        {
            return Min(source.Span);
        }

        public static <#=type#> Min(this Span<<#=type#>> source)
        {
            return Min((ReadOnlySpan<<#=type#>>)source);
        }

        public static <#=type#> Min(this ReadOnlySpan<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (<#=type#>* ptr = source)
            {
                MinCore(ptr, source.Length, out var result);
                return result;
            }
        }
<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Min.tt.meta
================================================
fileFormatVersion: 2
guid: 89ff07cc368864015b25aad430a8b665
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Average.cs
================================================
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static double Average(this NativeList<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeSlice<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeArray<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(int* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            SumCore(ptr, length, out var sum);
            result = (double)sum / length;
        }

        public static double Average(this NativeList<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeSlice<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeArray<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(uint* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            SumCore(ptr, length, out var sum);
            result = (double)sum / length;
        }

        public static double Average(this NativeList<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeSlice<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeArray<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(long* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            SumCore(ptr, length, out var sum);
            result = (double)sum / length;
        }

        public static double Average(this NativeList<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeSlice<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeArray<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(ulong* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            SumCore(ptr, length, out var sum);
            result = (double)sum / length;
        }

        public static float Average(this NativeList<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Average(this NativeSlice<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Average(this NativeArray<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(float* ptr, [AssumeRange(1, int.MaxValue)] int length, out float result)
        {
            SumCore(ptr, length, out var sum);
            result = (float)sum / length;
        }

        public static double Average(this NativeList<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeSlice<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Average(this NativeArray<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(double* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            SumCore(ptr, length, out var sum);
            result = (double)sum / length;
        }

        public static Vector2 Average(this NativeList<Vector2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2 Average(this NativeSlice<Vector2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2 Average(this NativeArray<Vector2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(Vector2* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector2 result)
        {
            SumCore(ptr, length, out var sum);
            result = (Vector2)sum / length;
        }

        public static Vector2 Average(this NativeList<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector2Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2 Average(this NativeSlice<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector2Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2 Average(this NativeArray<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector2Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(Vector2Int* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector2 result)
        {
            SumCore(ptr, length, out var sum);
            result = (Vector2)sum / length;
        }

        public static Vector3 Average(this NativeList<Vector3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3 Average(this NativeSlice<Vector3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3 Average(this NativeArray<Vector3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(Vector3* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector3 result)
        {
            SumCore(ptr, length, out var sum);
            result = (Vector3)sum / length;
        }

        public static Vector3 Average(this NativeList<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector3Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3 Average(this NativeSlice<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector3Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3 Average(this NativeArray<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector3Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(Vector3Int* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector3 result)
        {
            SumCore(ptr, length, out var sum);
            result = (Vector3)sum / length;
        }

        public static Vector4 Average(this NativeList<Vector4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector4 Average(this NativeSlice<Vector4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector4 Average(this NativeArray<Vector4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((Vector4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(Vector4* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector4 result)
        {
            SumCore(ptr, length, out var sum);
            result = (Vector4)sum / length;
        }

        public static double2 Average(this NativeList<int2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double2 Average(this NativeSlice<int2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double2 Average(this NativeArray<int2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(int2* ptr, [AssumeRange(1, int.MaxValue)] int length, out double2 result)
        {
            SumCore(ptr, length, out var sum);
            result = (double2)sum / length;
        }

        public static double3 Average(this NativeList<int3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double3 Average(this NativeSlice<int3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double3 Average(this NativeArray<int3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(int3* ptr, [AssumeRange(1, int.MaxValue)] int length, out double3 result)
        {
            SumCore(ptr, length, out var sum);
            result = (double3)sum / length;
        }

        public static double4 Average(this NativeList<int4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double4 Average(this NativeSlice<int4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double4 Average(this NativeArray<int4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((int4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(int4* ptr, [AssumeRange(1, int.MaxValue)] int length, out double4 result)
        {
            SumCore(ptr, length, out var sum);
            result = (double4)sum / length;
        }

        public static float2 Average(this NativeList<float2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float2 Average(this NativeSlice<float2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float2 Average(this NativeArray<float2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(float2* ptr, [AssumeRange(1, int.MaxValue)] int length, out float2 result)
        {
            SumCore(ptr, length, out var sum);
            result = (float2)sum / length;
        }

        public static float3 Average(this NativeList<float3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float3 Average(this NativeSlice<float3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float3 Average(this NativeArray<float3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(float3* ptr, [AssumeRange(1, int.MaxValue)] int length, out float3 result)
        {
            SumCore(ptr, length, out var sum);
            result = (float3)sum / length;
        }

        public static float4 Average(this NativeList<float4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float4 Average(this NativeSlice<float4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float4 Average(this NativeArray<float4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((float4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(float4* ptr, [AssumeRange(1, int.MaxValue)] int length, out float4 result)
        {
            SumCore(ptr, length, out var sum);
            result = (float4)sum / length;
        }

        public static double2 Average(this NativeList<double2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double2 Average(this NativeSlice<double2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double2 Average(this NativeArray<double2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(double2* ptr, [AssumeRange(1, int.MaxValue)] int length, out double2 result)
        {
            SumCore(ptr, length, out var sum);
            result = (double2)sum / length;
        }

        public static double3 Average(this NativeList<double3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double3 Average(this NativeSlice<double3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double3 Average(this NativeArray<double3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(double3* ptr, [AssumeRange(1, int.MaxValue)] int length, out double3 result)
        {
            SumCore(ptr, length, out var sum);
            result = (double3)sum / length;
        }

        public static double4 Average(this NativeList<double4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double4 Average(this NativeSlice<double4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double4 Average(this NativeArray<double4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((double4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(double4* ptr, [AssumeRange(1, int.MaxValue)] int length, out double4 result)
        {
            SumCore(ptr, length, out var sum);
            result = (double4)sum / length;
        }

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Average.cs.meta
================================================
fileFormatVersion: 2
guid: 9395d12cf09894920aa7da73fea1d6ea
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Average.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
    
    System.Func<string, string> retType = (string x) => 
    {
        switch (x)
        {
            default: return "double";
            case "float": return "float";
            case "Vector2":
            case "Vector2Int": return "Vector2";
            case "Vector3":
            case "Vector3Int": return "Vector3";
            case "Vector4": return "Vector4";
            case "float2": return "float2";
            case "float3": return "float3";
            case "float4": return "float4";
            case "int2":
            case "double2": return "double2";
            case "int3":
            case "double3": return "double3";
            case "int4":
            case "double4": return "double4";
        }
        return "";
    };
#>
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=retType(type)#> Average(this NativeList<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=retType(type)#> Average(this NativeSlice<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=retType(type)#> Average(this NativeArray<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            AverageCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }
        
        [BurstCompile]
        internal static void AverageCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, out <#=retType(type)#> result)
        {
            SumCore(ptr, length, out var sum);
            result = (<#=retType(type)#>)sum / length;
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Average.tt.meta
================================================
fileFormatVersion: 2
guid: e45c49a2aa40348b685f1b45af887076
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Contains.cs
================================================
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;
using System.Runtime.CompilerServices;
namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static bool Contains(this NativeList<byte> source, byte value)
        {
            return ContainsCore((byte*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<byte> source, byte value)
        {
            return ContainsCore((byte*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<byte> source, byte value)
        {
            return ContainsCore((byte*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(byte* ptr, [AssumeRange(1, int.MaxValue)] int length, in byte value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(byte);

                static bool32 _contains(v256 a, byte* b) => new bool32(
                    a.Byte0 == b[0],
                    a.Byte1 == b[1],
                    a.Byte2 == b[2],
                    a.Byte3 == b[3],
                    a.Byte4 == b[4],
                    a.Byte5 == b[5],
                    a.Byte6 == b[6],
                    a.Byte7 == b[7],
                    a.Byte8 == b[8],
                    a.Byte9 == b[9],
                    a.Byte10 == b[10],
                    a.Byte11 == b[11],
                    a.Byte12 == b[12],
                    a.Byte13 == b[13],
                    a.Byte14 == b[14],
                    a.Byte15 == b[15],
                    a.Byte16 == b[16],
                    a.Byte17 == b[17],
                    a.Byte18 == b[18],
                    a.Byte19 == b[19],
                    a.Byte20 == b[20],
                    a.Byte21 == b[21],
                    a.Byte22 == b[22],
                    a.Byte23 == b[23],
                    a.Byte24 == b[24],
                    a.Byte25 == b[25],
                    a.Byte26 == b[26],
                    a.Byte27 == b[27],
                    a.Byte28 == b[28],
                    a.Byte29 == b[29],
                    a.Byte30 == b[30],
                    a.Byte31 == b[31]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(byte);
              
                static bool16 _contains(v128 a, byte* b) => new bool16(
                    a.Byte0 == b[0],
                    a.Byte1 == b[1],
                    a.Byte2 == b[2],
                    a.Byte3 == b[3],
                    a.Byte4 == b[4],
                    a.Byte5 == b[5],
                    a.Byte6 == b[6],
                    a.Byte7 == b[7],
                    a.Byte8 == b[8],
                    a.Byte9 == b[9],
                    a.Byte10 == b[10],
                    a.Byte11 == b[11],
                    a.Byte12 == b[12],
                    a.Byte13 == b[13],
                    a.Byte14 == b[14],
                    a.Byte15 == b[15]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<sbyte> source, sbyte value)
        {
            return ContainsCore((sbyte*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<sbyte> source, sbyte value)
        {
            return ContainsCore((sbyte*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<sbyte> source, sbyte value)
        {
            return ContainsCore((sbyte*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(sbyte* ptr, [AssumeRange(1, int.MaxValue)] int length, in sbyte value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(sbyte);

                static bool32 _contains(v256 a, sbyte* b) => new bool32(
                    a.SByte0 == b[0],
                    a.SByte1 == b[1],
                    a.SByte2 == b[2],
                    a.SByte3 == b[3],
                    a.SByte4 == b[4],
                    a.SByte5 == b[5],
                    a.SByte6 == b[6],
                    a.SByte7 == b[7],
                    a.SByte8 == b[8],
                    a.SByte9 == b[9],
                    a.SByte10 == b[10],
                    a.SByte11 == b[11],
                    a.SByte12 == b[12],
                    a.SByte13 == b[13],
                    a.SByte14 == b[14],
                    a.SByte15 == b[15],
                    a.SByte16 == b[16],
                    a.SByte17 == b[17],
                    a.SByte18 == b[18],
                    a.SByte19 == b[19],
                    a.SByte20 == b[20],
                    a.SByte21 == b[21],
                    a.SByte22 == b[22],
                    a.SByte23 == b[23],
                    a.SByte24 == b[24],
                    a.SByte25 == b[25],
                    a.SByte26 == b[26],
                    a.SByte27 == b[27],
                    a.SByte28 == b[28],
                    a.SByte29 == b[29],
                    a.SByte30 == b[30],
                    a.SByte31 == b[31]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(sbyte);
              
                static bool16 _contains(v128 a, sbyte* b) => new bool16(
                    a.SByte0 == b[0],
                    a.SByte1 == b[1],
                    a.SByte2 == b[2],
                    a.SByte3 == b[3],
                    a.SByte4 == b[4],
                    a.SByte5 == b[5],
                    a.SByte6 == b[6],
                    a.SByte7 == b[7],
                    a.SByte8 == b[8],
                    a.SByte9 == b[9],
                    a.SByte10 == b[10],
                    a.SByte11 == b[11],
                    a.SByte12 == b[12],
                    a.SByte13 == b[13],
                    a.SByte14 == b[14],
                    a.SByte15 == b[15]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<short> source, short value)
        {
            return ContainsCore((short*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<short> source, short value)
        {
            return ContainsCore((short*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<short> source, short value)
        {
            return ContainsCore((short*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(short* ptr, [AssumeRange(1, int.MaxValue)] int length, in short value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(short);

                static bool16 _contains(v256 a, short* b) => new bool16(
                    a.SShort0 == b[0],
                    a.SShort1 == b[1],
                    a.SShort2 == b[2],
                    a.SShort3 == b[3],
                    a.SShort4 == b[4],
                    a.SShort5 == b[5],
                    a.SShort6 == b[6],
                    a.SShort7 == b[7],
                    a.SShort8 == b[8],
                    a.SShort9 == b[9],
                    a.SShort10 == b[10],
                    a.SShort11 == b[11],
                    a.SShort12 == b[12],
                    a.SShort13 == b[13],
                    a.SShort14 == b[14],
                    a.SShort15 == b[15]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(short);
              
                static bool8 _contains(v128 a, short* b) => new bool8(
                    a.SShort0 == b[0],
                    a.SShort1 == b[1],
                    a.SShort2 == b[2],
                    a.SShort3 == b[3],
                    a.SShort4 == b[4],
                    a.SShort5 == b[5],
                    a.SShort6 == b[6],
                    a.SShort7 == b[7]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<ushort> source, ushort value)
        {
            return ContainsCore((ushort*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<ushort> source, ushort value)
        {
            return ContainsCore((ushort*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<ushort> source, ushort value)
        {
            return ContainsCore((ushort*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(ushort* ptr, [AssumeRange(1, int.MaxValue)] int length, in ushort value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(ushort);

                static bool16 _contains(v256 a, ushort* b) => new bool16(
                    a.UShort0 == b[0],
                    a.UShort1 == b[1],
                    a.UShort2 == b[2],
                    a.UShort3 == b[3],
                    a.UShort4 == b[4],
                    a.UShort5 == b[5],
                    a.UShort6 == b[6],
                    a.UShort7 == b[7],
                    a.UShort8 == b[8],
                    a.UShort9 == b[9],
                    a.UShort10 == b[10],
                    a.UShort11 == b[11],
                    a.UShort12 == b[12],
                    a.UShort13 == b[13],
                    a.UShort14 == b[14],
                    a.UShort15 == b[15]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(ushort);
              
                static bool8 _contains(v128 a, ushort* b) => new bool8(
                    a.UShort0 == b[0],
                    a.UShort1 == b[1],
                    a.UShort2 == b[2],
                    a.UShort3 == b[3],
                    a.UShort4 == b[4],
                    a.UShort5 == b[5],
                    a.UShort6 == b[6],
                    a.UShort7 == b[7]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<int> source, int value)
        {
            return ContainsCore((int*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<int> source, int value)
        {
            return ContainsCore((int*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<int> source, int value)
        {
            return ContainsCore((int*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(int* ptr, [AssumeRange(1, int.MaxValue)] int length, in int value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(int);

                static bool8 _contains(v256 a, int* b) => new bool8(
                    a.SInt0 == b[0],
                    a.SInt1 == b[1],
                    a.SInt2 == b[2],
                    a.SInt3 == b[3],
                    a.SInt4 == b[4],
                    a.SInt5 == b[5],
                    a.SInt6 == b[6],
                    a.SInt7 == b[7]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(int);
              
                static bool4 _contains(v128 a, int* b) => new bool4(
                    a.SInt0 == b[0],
                    a.SInt1 == b[1],
                    a.SInt2 == b[2],
                    a.SInt3 == b[3]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<uint> source, uint value)
        {
            return ContainsCore((uint*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<uint> source, uint value)
        {
            return ContainsCore((uint*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<uint> source, uint value)
        {
            return ContainsCore((uint*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(uint* ptr, [AssumeRange(1, int.MaxValue)] int length, in uint value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(uint);

                static bool8 _contains(v256 a, uint* b) => new bool8(
                    a.UInt0 == b[0],
                    a.UInt1 == b[1],
                    a.UInt2 == b[2],
                    a.UInt3 == b[3],
                    a.UInt4 == b[4],
                    a.UInt5 == b[5],
                    a.UInt6 == b[6],
                    a.UInt7 == b[7]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(uint);
              
                static bool4 _contains(v128 a, uint* b) => new bool4(
                    a.UInt0 == b[0],
                    a.UInt1 == b[1],
                    a.UInt2 == b[2],
                    a.UInt3 == b[3]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<long> source, long value)
        {
            return ContainsCore((long*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<long> source, long value)
        {
            return ContainsCore((long*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<long> source, long value)
        {
            return ContainsCore((long*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(long* ptr, [AssumeRange(1, int.MaxValue)] int length, in long value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(long);

                static bool4 _contains(v256 a, long* b) => new bool4(
                    a.SLong0 == b[0],
                    a.SLong1 == b[1],
                    a.SLong2 == b[2],
                    a.SLong3 == b[3]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(long);
              
                static bool2 _contains(v128 a, long* b) => new bool2(
                    a.SLong0 == b[0],
                    a.SLong1 == b[1]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<ulong> source, ulong value)
        {
            return ContainsCore((ulong*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<ulong> source, ulong value)
        {
            return ContainsCore((ulong*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<ulong> source, ulong value)
        {
            return ContainsCore((ulong*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(ulong* ptr, [AssumeRange(1, int.MaxValue)] int length, in ulong value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(ulong);

                static bool4 _contains(v256 a, ulong* b) => new bool4(
                    a.ULong0 == b[0],
                    a.ULong1 == b[1],
                    a.ULong2 == b[2],
                    a.ULong3 == b[3]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(ulong);
              
                static bool2 _contains(v128 a, ulong* b) => new bool2(
                    a.ULong0 == b[0],
                    a.ULong1 == b[1]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<float> source, float value)
        {
            return ContainsCore((float*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<float> source, float value)
        {
            return ContainsCore((float*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<float> source, float value)
        {
            return ContainsCore((float*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(float* ptr, [AssumeRange(1, int.MaxValue)] int length, in float value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(float);

                static bool8 _contains(v256 a, float* b) => new bool8(
                    a.Float0 == b[0],
                    a.Float1 == b[1],
                    a.Float2 == b[2],
                    a.Float3 == b[3],
                    a.Float4 == b[4],
                    a.Float5 == b[5],
                    a.Float6 == b[6],
                    a.Float7 == b[7]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(float);
              
                static bool4 _contains(v128 a, float* b) => new bool4(
                    a.Float0 == b[0],
                    a.Float1 == b[1],
                    a.Float2 == b[2],
                    a.Float3 == b[3]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<double> source, double value)
        {
            return ContainsCore((double*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<double> source, double value)
        {
            return ContainsCore((double*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<double> source, double value)
        {
            return ContainsCore((double*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(double* ptr, [AssumeRange(1, int.MaxValue)] int length, in double value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(double);

                static bool4 _contains(v256 a, double* b) => new bool4(
                    a.Double0 == b[0],
                    a.Double1 == b[1],
                    a.Double2 == b[2],
                    a.Double3 == b[3]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(double);
              
                static bool2 _contains(v128 a, double* b) => new bool2(
                    a.Double0 == b[0],
                    a.Double1 == b[1]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<Vector2> source, Vector2 value)
        {
            return ContainsCore((Vector2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<Vector2> source, Vector2 value)
        {
            return ContainsCore((Vector2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<Vector2> source, Vector2 value)
        {
            return ContainsCore((Vector2*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(Vector2* ptr, [AssumeRange(0, int.MaxValue)] int length, in Vector2 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<Vector2Int> source, Vector2Int value)
        {
            return ContainsCore((Vector2Int*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<Vector2Int> source, Vector2Int value)
        {
            return ContainsCore((Vector2Int*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<Vector2Int> source, Vector2Int value)
        {
            return ContainsCore((Vector2Int*)source.GetUnsafePtr(), source.Length, value);
        }

        internal static bool ContainsCore(Vector2Int* ptr, [AssumeRange(1, int.MaxValue)] int length, in Vector2Int value)
        {
            var temp = value;
            var union = *(long*)&temp;
            return ContainsCore((long*)ptr, length, union);
        }
        public static bool Contains(this NativeList<Vector3> source, Vector3 value)
        {
            return ContainsCore((Vector3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<Vector3> source, Vector3 value)
        {
            return ContainsCore((Vector3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<Vector3> source, Vector3 value)
        {
            return ContainsCore((Vector3*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(Vector3* ptr, [AssumeRange(0, int.MaxValue)] int length, in Vector3 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<Vector3Int> source, Vector3Int value)
        {
            return ContainsCore((Vector3Int*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<Vector3Int> source, Vector3Int value)
        {
            return ContainsCore((Vector3Int*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<Vector3Int> source, Vector3Int value)
        {
            return ContainsCore((Vector3Int*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(Vector3Int* ptr, [AssumeRange(0, int.MaxValue)] int length, in Vector3Int value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<Vector4> source, Vector4 value)
        {
            return ContainsCore((Vector4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<Vector4> source, Vector4 value)
        {
            return ContainsCore((Vector4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<Vector4> source, Vector4 value)
        {
            return ContainsCore((Vector4*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(Vector4* ptr, [AssumeRange(0, int.MaxValue)] int length, in Vector4 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<int2> source, int2 value)
        {
            return ContainsCore((int2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<int2> source, int2 value)
        {
            return ContainsCore((int2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<int2> source, int2 value)
        {
            return ContainsCore((int2*)source.GetUnsafePtr(), source.Length, value);
        }

        internal static bool ContainsCore(int2* ptr, [AssumeRange(1, int.MaxValue)] int length, in int2 value)
        {
            var temp = value;
            var union = *(long*)&temp;
            return ContainsCore((long*)ptr, length, union);
        }
        public static bool Contains(this NativeList<int3> source, int3 value)
        {
            return ContainsCore((int3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<int3> source, int3 value)
        {
            return ContainsCore((int3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<int3> source, int3 value)
        {
            return ContainsCore((int3*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(int3* ptr, [AssumeRange(0, int.MaxValue)] int length, in int3 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<int4> source, int4 value)
        {
            return ContainsCore((int4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<int4> source, int4 value)
        {
            return ContainsCore((int4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<int4> source, int4 value)
        {
            return ContainsCore((int4*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(int4* ptr, [AssumeRange(0, int.MaxValue)] int length, in int4 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<uint2> source, uint2 value)
        {
            return ContainsCore((uint2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<uint2> source, uint2 value)
        {
            return ContainsCore((uint2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<uint2> source, uint2 value)
        {
            return ContainsCore((uint2*)source.GetUnsafePtr(), source.Length, value);
        }

        internal static bool ContainsCore(uint2* ptr, [AssumeRange(1, int.MaxValue)] int length, in uint2 value)
        {
            var temp = value;
            var union = *(long*)&temp;
            return ContainsCore((long*)ptr, length, union);
        }
        public static bool Contains(this NativeList<uint3> source, uint3 value)
        {
            return ContainsCore((uint3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<uint3> source, uint3 value)
        {
            return ContainsCore((uint3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<uint3> source, uint3 value)
        {
            return ContainsCore((uint3*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(uint3* ptr, [AssumeRange(0, int.MaxValue)] int length, in uint3 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<uint4> source, uint4 value)
        {
            return ContainsCore((uint4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<uint4> source, uint4 value)
        {
            return ContainsCore((uint4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<uint4> source, uint4 value)
        {
            return ContainsCore((uint4*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(uint4* ptr, [AssumeRange(0, int.MaxValue)] int length, in uint4 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<float2> source, float2 value)
        {
            return ContainsCore((float2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<float2> source, float2 value)
        {
            return ContainsCore((float2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<float2> source, float2 value)
        {
            return ContainsCore((float2*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(float2* ptr, [AssumeRange(0, int.MaxValue)] int length, in float2 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<float3> source, float3 value)
        {
            return ContainsCore((float3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<float3> source, float3 value)
        {
            return ContainsCore((float3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<float3> source, float3 value)
        {
            return ContainsCore((float3*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(float3* ptr, [AssumeRange(0, int.MaxValue)] int length, in float3 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<float4> source, float4 value)
        {
            return ContainsCore((float4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<float4> source, float4 value)
        {
            return ContainsCore((float4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<float4> source, float4 value)
        {
            return ContainsCore((float4*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(float4* ptr, [AssumeRange(0, int.MaxValue)] int length, in float4 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<double2> source, double2 value)
        {
            return ContainsCore((double2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<double2> source, double2 value)
        {
            return ContainsCore((double2*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<double2> source, double2 value)
        {
            return ContainsCore((double2*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(double2* ptr, [AssumeRange(0, int.MaxValue)] int length, in double2 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<double3> source, double3 value)
        {
            return ContainsCore((double3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<double3> source, double3 value)
        {
            return ContainsCore((double3*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<double3> source, double3 value)
        {
            return ContainsCore((double3*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(double3* ptr, [AssumeRange(0, int.MaxValue)] int length, in double3 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
        public static bool Contains(this NativeList<double4> source, double4 value)
        {
            return ContainsCore((double4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<double4> source, double4 value)
        {
            return ContainsCore((double4*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<double4> source, double4 value)
        {
            return ContainsCore((double4*)source.GetUnsafePtr(), source.Length, value);
        }

        [BurstCompile]
        internal static bool ContainsCore(double4* ptr, [AssumeRange(0, int.MaxValue)] int length, in double4 value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Contains.cs.meta
================================================
fileFormatVersion: 2
guid: 7373cb17d160e40e9a94e729f79067b4
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Contains.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };

    bool IsPrimitive(string type)
    {
        return type is  "byte"or  "sbyte"or  "short"or  "ushort"or "int" or "uint" or "float" or "double" or "long" or "ulong";
    }
    
    string V256Name(string type)
    {
        switch (@type) {
            case "sbyte": return "SByte";
            case "byte": return "Byte";
            case "short": return "SShort";
            case "ushort": return "UShort";
            case "int": return "SInt";
            case "uint": return "UInt";
            case "long": return "SLong";
            case "ulong": return "ULong";
            case "float": return "Float";
            case "double": return "Double";
        }
        throw new Exception("Invalid type");
    }

    int Size(string type)
    {
        switch (@type) 
        {
            case "sbyte": return 1;
            case "byte": return 1;
            case "short": return 2;
            case "ushort": return 2;
            case "int": return 4;
            case "uint": return 4;
            case "long": return 8;
            case "ulong": return 8;
            case "float": return 4;
            case "double": return 8;
            case "Vector2": return sizeof(float) * 2;
            case "Vector2Int": return sizeof(int) * 2;
            case "Vector3": return sizeof(float) * 3;
            case "Vector3Int": return sizeof(int) * 3;
            case "Vector4": return sizeof(float) * 4;
            case "int2": return sizeof(int) * 2;
            case "int3": return sizeof(int) * 3;
            case "int4": return sizeof(int) * 4;
            case "uint2": return sizeof(uint) * 2;
            case "uint3": return sizeof(uint) * 3;
            case "uint4": return sizeof(uint) * 4;
            case "float2": return sizeof(float) * 2;
            case "float3": return sizeof(float) * 3;
            case "float4": return sizeof(float) * 4;
            case "double2": return sizeof(double) * 2;
            case "double3": return sizeof(double) * 3;
            case "double4": return sizeof(double) * 4;
        }

        throw new Exception("Invalid type");
    }

    bool TryGetInteger(string type, out string type2)
    {
        type2 = null;
        switch (type)
        {
            case "int2": type2 = "long"; return true;
            case "uint2": type2 = "long"; return true;
            case "Vector2Int": type2 = "long"; return true;
            default: return false;
        }
    }
#>
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;
using System.Runtime.CompilerServices;
namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static bool Contains(this NativeList<<#=type#>> source, <#=type#> value)
        {
            return ContainsCore((<#=type#>*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeSlice<<#=type#>> source, <#=type#> value)
        {
            return ContainsCore((<#=type#>*)source.GetUnsafePtr(), source.Length, value);
        }

        public static bool Contains(this NativeArray<<#=type#>> source, <#=type#> value)
        {
            return ContainsCore((<#=type#>*)source.GetUnsafePtr(), source.Length, value);
        }

<#if (TryGetInteger(type, out var intType)){#>
        internal static bool ContainsCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, in <#=type#> value)
        {
            var temp = value;
            var union = *(<#=intType#>*)&temp;
            return ContainsCore((<#=intType#>*)ptr, length, union);
        }
<#} else if (IsPrimitive(type)) { #>
<#var vName = V256Name(type);#>
        [BurstCompile]
        internal static bool ContainsCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, in <#=type#> value)
        {
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                const int packingLength = 32 / sizeof(<#=type#>);

<# int vectorLength=32/Size(type);string typeName = V256Name(type);#>
                static bool<#=vectorLength#> _contains(v256 a, <#=type#>* b) => new bool<#=vectorLength#>(
<# for (int i =0;i<vectorLength-1;i++) {#>
                    a.<#=typeName+i#> == b[<#=i#>],
<# } #>
                    a.<#=typeName+(vectorLength-1)#> == b[<#=vectorLength-1#>]
                );
                
                if (0 < length / packingLength) 
                {
                    var valueVector = new v256(value);
                    for (; index < length-packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                const int packingLength = 16 / sizeof(<#=type#>);
              
                static bool<#=vectorLength/2#> _contains(v128 a, <#=type#>* b) => new bool<#=vectorLength/2#>(
<# for (int i = 0; i < vectorLength / 2 - 1; i++) {#>
                    a.<#=typeName + i#> == b[<#=i#>],
<# } #>
                    a.<#=typeName + (vectorLength / 2 - 1)#> == b[<#=vectorLength / 2 - 1#>]
                );

                if (0 < length / packingLength)
                {
                    var valueVector = new v128(value);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        if(_contains(valueVector, ptr + index).any()) return true;
                    }
                }
            }

            for (; index < length; index++)
            {
                if (ptr[index] == value) return true;
            }

            return false;
        }
<#} else { #>
        [BurstCompile]
        internal static bool ContainsCore(<#=type#>* ptr, [AssumeRange(0, int.MaxValue)] int length, in <#=type#> value)
        {
            for (int i = 0; i < length; i++)
            {
                if (ptr[i].Equals(value)) return true;
            }

            return false;
        }
<# } #>
<# } #>

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Contains.tt.meta
================================================
fileFormatVersion: 2
guid: 13b5d1c751c4848cd81a19097cbdb5a6
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Max.cs
================================================
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using static Unity.Burst.Intrinsics.Arm.Neon;

namespace BurstLinq
{  
    public unsafe static partial class BurstLinqExtensions
    {
        public static byte Max(this NativeList<byte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((byte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static byte Max(this NativeSlice<byte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((byte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static byte Max(this NativeArray<byte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((byte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(byte* ptr, [AssumeRange(1, int.MaxValue)] int length, out byte result)
        {
            var tempResult = byte.MinValue;
            static byte _max(byte a, byte b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static sbyte Max(this NativeList<sbyte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((sbyte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static sbyte Max(this NativeSlice<sbyte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((sbyte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static sbyte Max(this NativeArray<sbyte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((sbyte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(sbyte* ptr, [AssumeRange(1, int.MaxValue)] int length, out sbyte result)
        {
            var tempResult = sbyte.MinValue;
            static sbyte _max(sbyte a, sbyte b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static short Max(this NativeList<short> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((short*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static short Max(this NativeSlice<short> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((short*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static short Max(this NativeArray<short> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((short*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(short* ptr, [AssumeRange(1, int.MaxValue)] int length, out short result)
        {
            var tempResult = short.MinValue;
            static short _max(short a, short b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static ushort Max(this NativeList<ushort> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((ushort*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ushort Max(this NativeSlice<ushort> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((ushort*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ushort Max(this NativeArray<ushort> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((ushort*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(ushort* ptr, [AssumeRange(1, int.MaxValue)] int length, out ushort result)
        {
            var tempResult = ushort.MinValue;
            static ushort _max(ushort a, ushort b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static int Max(this NativeList<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int Max(this NativeSlice<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int Max(this NativeArray<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(int* ptr, [AssumeRange(1, int.MaxValue)] int length, out int result)
        {
            var tempResult = int.MinValue;
            static int _max(int a, int b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static uint Max(this NativeList<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint Max(this NativeSlice<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint Max(this NativeArray<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(uint* ptr, [AssumeRange(1, int.MaxValue)] int length, out uint result)
        {
            var tempResult = uint.MinValue;
            static uint _max(uint a, uint b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static long Max(this NativeList<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static long Max(this NativeSlice<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static long Max(this NativeArray<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(long* ptr, [AssumeRange(1, int.MaxValue)] int length, out long result)
        {
            var tempResult = long.MinValue;
            static long _max(long a, long b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static ulong Max(this NativeList<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ulong Max(this NativeSlice<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ulong Max(this NativeArray<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(ulong* ptr, [AssumeRange(1, int.MaxValue)] int length, out ulong result)
        {
            var tempResult = ulong.MinValue;
            static ulong _max(ulong a, ulong b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static float Max(this NativeList<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Max(this NativeSlice<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Max(this NativeArray<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(float* ptr, [AssumeRange(1, int.MaxValue)] int length, out float result)
        {
            var tempResult = float.MinValue;
            static float _max(float a, float b) => IsNeonSupported ? math.max(a,b) : a > b ? a : b;
            
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static v256 _max256(v256 a, float* b) => new v256(
                    _max(a.Float0, b[0]),
                    _max(a.Float1, b[1]),
                    _max(a.Float2, b[2]),
                    _max(a.Float3, b[3]),
                    _max(a.Float4, b[4]),
                    _max(a.Float5, b[5]),
                    _max(a.Float6, b[6]),
                    _max(a.Float7, b[7])
                );
                
                var packingLength = sizeof(v256) / sizeof(float);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v256(float.MinValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _max256(temp, (ptr+index));
                    }
                    float* tempAsArray = (float*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _max(tempResult, tempAsArray[i]);
                    }
                }    
             }
             else if (BurstHelpers.IsV128Supported)
             {
                static v128 _max128(v128 a, float* b) => new v128(
                    _max(a.Float0, b[0]),
                    _max(a.Float1, b[1]),
                    _max(a.Float2, b[2]),
                    _max(a.Float3, b[3])
                );
                
                var packingLength = sizeof(v128) / sizeof(float);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v128(float.MinValue);
                    for (; index < length-packingLength; index+=packingLength)
                    {
                        temp = _max128(temp, ptr + index);
                    }
                    float* tempAsArray = (float*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _max(tempResult, tempAsArray[i]);
                    }
                }
            }

            for (; index < length; index++)
            {
                tempResult = _max(tempResult, ptr[index]);
            }

            result = tempResult;
        }

        public static double Max(this NativeList<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Max(this NativeSlice<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Max(this NativeArray<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(double* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            var tempResult = double.MinValue;
            static double _max(double a, double b) => IsNeonSupported ? math.max(a,b) : a > b ? a : b;
            
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static v256 _max256(v256 a, double* b) => new v256(
                    _max(a.Double0, b[0]),
                    _max(a.Double1, b[1]),
                    _max(a.Double2, b[2]),
                    _max(a.Double3, b[3])
                );
                
                var packingLength = sizeof(v256) / sizeof(double);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v256(double.MinValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _max256(temp, (ptr+index));
                    }
                    double* tempAsArray = (double*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _max(tempResult, tempAsArray[i]);
                    }
                }    
             }
             else if (BurstHelpers.IsV128Supported)
             {
                static v128 _max128(v128 a, double* b) => new v128(
                    _max(a.Double0, b[0]),
                    _max(a.Double1, b[1])
                );
                
                var packingLength = sizeof(v128) / sizeof(double);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v128(double.MinValue);
                    for (; index < length-packingLength; index+=packingLength)
                    {
                        temp = _max128(temp, ptr + index);
                    }
                    double* tempAsArray = (double*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _max(tempResult, tempAsArray[i]);
                    }
                }
            }

            for (; index < length; index++)
            {
                tempResult = _max(tempResult, ptr[index]);
            }

            result = tempResult;
        }

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Max.cs.meta
================================================
fileFormatVersion: 2
guid: cf9842e279ad54c088165db4c0c98505
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Max.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double"
    };

    string V256Name(string type)
    {
        switch (@type)
        {
            case "sbyte": return "SByte";
            case "byte": return "Byte";
            case "short": return "SShort";
            case "ushort": return "UShort";
            case "int": return "SInt";
            case "uint": return "UInt";
            case "long": return "SLong";
            case "ulong": return "ULong";
            case "float": return "Float";
            case "double": return "Double";
        }
        throw new Exception("Invalid type");
    }

    int Size(string type)
    {
        switch (@type)
        {
            case "sbyte": return 1;
            case "byte": return 1;
            case "short": return 2;
            case "ushort": return 2;
            case "int": return 4;
            case "uint": return 4;
            case "long": return 8;
            case "ulong": return 8;
            case "float": return 4;
            case "double": return 8;
        }
        throw new Exception("Invalid type");
    }

    bool IsFloating(string type)
    {
        return type is "float" or "double";
    }
#>
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using static Unity.Burst.Intrinsics.Arm.Neon;

namespace BurstLinq
{  
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=type#> Max(this NativeList<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=type#> Max(this NativeSlice<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=type#> Max(this NativeArray<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MaxCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MaxCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, out <#=type#> result)
        {
            var tempResult = <#=type#>.MinValue;
<# if (IsFloating(type)) {#>
            static <#=type#> _max(<#=type#> a, <#=type#> b) => IsNeonSupported ? math.max(a,b) : a > b ? a : b;
            
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static v256 _max256(v256 a, <#=type#>* b) => new v256(
<#int vectorLength = 32 / Size(type); string typeName = V256Name(type);
for (int i = 0; i < vectorLength - 1; i++) {#>
                    _max(a.<#=typeName+i#>, b[<#=i#>]),
<# } #>
                    _max(a.<#=typeName+(vectorLength-1)#>, b[<#=(vectorLength-1)#>])
                );
                
                var packingLength = sizeof(v256) / sizeof(<#=type#>);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v256(<#=type#>.MinValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _max256(temp, (ptr+index));
                    }
                    <#=type#>* tempAsArray = (<#=type#>*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _max(tempResult, tempAsArray[i]);
                    }
                }    
             }
             else if (BurstHelpers.IsV128Supported)
             {
                static v128 _max128(v128 a, <#=type#>* b) => new v128(
<# for (int i = 0; i < vectorLength / 2 - 1; i++) { #>
                    _max(a.<#=typeName+i#>, b[<#=i#>]),
<# } #>
                    _max(a.<#=typeName+(vectorLength / 2 - 1)#>, b[<#=(vectorLength / 2 - 1)#>])
                );
                
                var packingLength = sizeof(v128) / sizeof(<#=type#>);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v128(<#=type#>.MinValue);
                    for (; index < length-packingLength; index+=packingLength)
                    {
                        temp = _max128(temp, ptr + index);
                    }
                    <#=type#>* tempAsArray = (<#=type#>*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _max(tempResult, tempAsArray[i]);
                    }
                }
            }

            for (; index < length; index++)
            {
                tempResult = _max(tempResult, ptr[index]);
            }

            result = tempResult;
<# } else {#>
            static <#=type#> _max(<#=type#> a, <#=type#> b) => a > b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _max(tempResult, ptr[i]);
            }

            result = tempResult;
<# } #>
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Max.tt.meta
================================================
fileFormatVersion: 2
guid: 893b1e940b35d42019993a688cd20bf2
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Min.cs
================================================
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using static Unity.Burst.Intrinsics.Arm.Neon;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static byte Min(this NativeList<byte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((byte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static byte Min(this NativeSlice<byte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((byte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static byte Min(this NativeArray<byte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((byte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(byte* ptr, [AssumeRange(1, int.MaxValue)] int length, out byte result)
        {
            var tempResult = byte.MaxValue;
            static byte _min(byte a, byte b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static sbyte Min(this NativeList<sbyte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((sbyte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static sbyte Min(this NativeSlice<sbyte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((sbyte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static sbyte Min(this NativeArray<sbyte> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((sbyte*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(sbyte* ptr, [AssumeRange(1, int.MaxValue)] int length, out sbyte result)
        {
            var tempResult = sbyte.MaxValue;
            static sbyte _min(sbyte a, sbyte b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static short Min(this NativeList<short> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((short*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static short Min(this NativeSlice<short> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((short*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static short Min(this NativeArray<short> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((short*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(short* ptr, [AssumeRange(1, int.MaxValue)] int length, out short result)
        {
            var tempResult = short.MaxValue;
            static short _min(short a, short b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static ushort Min(this NativeList<ushort> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((ushort*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ushort Min(this NativeSlice<ushort> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((ushort*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ushort Min(this NativeArray<ushort> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((ushort*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(ushort* ptr, [AssumeRange(1, int.MaxValue)] int length, out ushort result)
        {
            var tempResult = ushort.MaxValue;
            static ushort _min(ushort a, ushort b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static int Min(this NativeList<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int Min(this NativeSlice<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int Min(this NativeArray<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(int* ptr, [AssumeRange(1, int.MaxValue)] int length, out int result)
        {
            var tempResult = int.MaxValue;
            static int _min(int a, int b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static uint Min(this NativeList<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint Min(this NativeSlice<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint Min(this NativeArray<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(uint* ptr, [AssumeRange(1, int.MaxValue)] int length, out uint result)
        {
            var tempResult = uint.MaxValue;
            static uint _min(uint a, uint b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static long Min(this NativeList<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static long Min(this NativeSlice<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static long Min(this NativeArray<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(long* ptr, [AssumeRange(1, int.MaxValue)] int length, out long result)
        {
            var tempResult = long.MaxValue;
            static long _min(long a, long b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static ulong Min(this NativeList<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ulong Min(this NativeSlice<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ulong Min(this NativeArray<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(ulong* ptr, [AssumeRange(1, int.MaxValue)] int length, out ulong result)
        {
            var tempResult = ulong.MaxValue;
            static ulong _min(ulong a, ulong b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
        }

        public static float Min(this NativeList<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Min(this NativeSlice<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Min(this NativeArray<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(float* ptr, [AssumeRange(1, int.MaxValue)] int length, out float result)
        {
            var tempResult = float.MaxValue;
            static float _min(float a, float b) => IsNeonSupported ? math.min(a,b): a < b ? a : b;
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static v256 _min256(v256 a, float* b) => new v256(
                    _min(a.Float0, b[0]),
                    _min(a.Float1, b[1]),
                    _min(a.Float2, b[2]),
                    _min(a.Float3, b[3]),
                    _min(a.Float4, b[4]),
                    _min(a.Float5, b[5]),
                    _min(a.Float6, b[6]),
                    _min(a.Float7, b[7])
                );
                
                var packingLength = sizeof(v256) / sizeof(float);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v256(float.MaxValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _min256(temp, ptr+index);
                    }
                    float* tempAsArray = (float*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _min(tempResult, tempAsArray[i]);
                    }
                }    
            }
            else if (BurstHelpers.IsV128Supported)
            {
                static v128 _min128(v128 a, float* b) => new v128(
                    _min(a.Float0, b[0]),
                    _min(a.Float1, b[1]),
                    _min(a.Float2, b[2]),
                    _min(a.Float3, b[3])
                );
                
                var packingLength = sizeof(v128) / sizeof(float);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v128(float.MaxValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _min128(temp, ptr+index);
                    }
                    float* tempAsArray = (float*) &temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _min(tempResult, tempAsArray[i]);
                    }
                }
            }

            for (; index < length; index++)
            {
                tempResult = _min(tempResult, ptr[index]);
            }

            result =  tempResult;
        }

        public static double Min(this NativeList<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Min(this NativeSlice<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Min(this NativeArray<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(double* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            var tempResult = double.MaxValue;
            static double _min(double a, double b) => IsNeonSupported ? math.min(a,b): a < b ? a : b;
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static v256 _min256(v256 a, double* b) => new v256(
                    _min(a.Double0, b[0]),
                    _min(a.Double1, b[1]),
                    _min(a.Double2, b[2]),
                    _min(a.Double3, b[3])
                );
                
                var packingLength = sizeof(v256) / sizeof(double);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v256(double.MaxValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _min256(temp, ptr+index);
                    }
                    double* tempAsArray = (double*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _min(tempResult, tempAsArray[i]);
                    }
                }    
            }
            else if (BurstHelpers.IsV128Supported)
            {
                static v128 _min128(v128 a, double* b) => new v128(
                    _min(a.Double0, b[0]),
                    _min(a.Double1, b[1])
                );
                
                var packingLength = sizeof(v128) / sizeof(double);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v128(double.MaxValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _min128(temp, ptr+index);
                    }
                    double* tempAsArray = (double*) &temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _min(tempResult, tempAsArray[i]);
                    }
                }
            }

            for (; index < length; index++)
            {
                tempResult = _min(tempResult, ptr[index]);
            }

            result =  tempResult;
        }

        
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Min.cs.meta
================================================
fileFormatVersion: 2
guid: de88d273ca0384b83950cbdeff2ade41
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Min.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double"
    };

    string V256Name(string type)
    {
        switch (@type)
        {
            case "sbyte": return "SByte";
            case "byte": return "Byte";
            case "short": return "SShort";
            case "ushort": return "UShort";
            case "int": return "SInt";
            case "uint": return "UInt";
            case "long": return "SLong";
            case "ulong": return "ULong";
            case "float": return "Float";
            case "double": return "Double";
        }
        throw new Exception("Invalid type");
    }

    int Size(string type)
    {
        switch (@type)
        {
            case "sbyte": return 1;
            case "byte": return 1;
            case "short": return 2;
            case "ushort": return 2;
            case "int": return 4;
            case "uint": return 4;
            case "long": return 8;
            case "ulong": return 8;
            case "float": return 4;
            case "double": return 8;
        }
        throw new Exception("Invalid type");
    }
    
    bool IsFloating(string type)
    {
        return type is "float" or "double";
    }
#>
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using static Unity.Burst.Intrinsics.Arm.Neon;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=type#> Min(this NativeList<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=type#> Min(this NativeSlice<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=type#> Min(this NativeArray<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            MinCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile]
        internal static void MinCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, out <#=type#> result)
        {
            var tempResult = <#=type#>.MaxValue;
<# if (IsFloating(type)) {#>
            static <#=type#> _min(<#=type#> a, <#=type#> b) => IsNeonSupported ? math.min(a,b): a < b ? a : b;
            var index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static v256 _min256(v256 a, <#=type#>* b) => new v256(
<# int vectorLength = 32 / Size(type); string typeName = V256Name(type);
for (int i = 0; i < vectorLength - 1; i++) {#>
                    _min(a.<#=typeName+i#>, b[<#=i#>]),
<# } #>
                    _min(a.<#=typeName+(vectorLength-1)#>, b[<#=(vectorLength-1)#>])
                );
                
                var packingLength = sizeof(v256) / sizeof(<#=type#>);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v256(<#=type#>.MaxValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _min256(temp, ptr+index);
                    }
                    <#=type#>* tempAsArray = (<#=type#>*)&temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _min(tempResult, tempAsArray[i]);
                    }
                }    
            }
            else if (BurstHelpers.IsV128Supported)
            {
                static v128 _min128(v128 a, <#=type#>* b) => new v128(
<# for (int i =0;i<vectorLength/2-1;i++) {#>
                    _min(a.<#=typeName+i#>, b[<#=i#>]),
<# } #>
                    _min(a.<#=typeName+(vectorLength/2-1)#>, b[<#=vectorLength/2-1#>])
                );
                
                var packingLength = sizeof(v128) / sizeof(<#=type#>);
                 
                if (0 < length / packingLength)
                {
                    var temp = new v128(<#=type#>.MaxValue);
                    for (; index < length - packingLength; index += packingLength)
                    {
                        temp = _min128(temp, ptr+index);
                    }
                    <#=type#>* tempAsArray = (<#=type#>*) &temp;
                    for (int i = 0; i < packingLength; i++)
                    {
                        tempResult = _min(tempResult, tempAsArray[i]);
                    }
                }
            }

            for (; index < length; index++)
            {
                tempResult = _min(tempResult, ptr[index]);
            }

            result =  tempResult;
<# } else {#>
            static <#=type#> _min(<#=type#> a, <#=type#> b) => a < b ? a : b;
        
            for (var i = 0; i < length; i++)
            {
                tempResult = _min(tempResult, ptr[i]);
            }

            result = tempResult;
<# } #>
        }

<# } #>
        
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Min.tt.meta
================================================
fileFormatVersion: 2
guid: 2aec1a558601c493da363c3c64bef216
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.SequenceEqual.cs
================================================

using System.Runtime.CompilerServices;
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static bool SequenceEqual(this NativeList<byte> first, NativeList<byte> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((byte*)first.GetUnsafePtr(), (byte*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<byte> first, NativeSlice<byte> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((byte*)first.GetUnsafePtr(), (byte*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<byte> first, NativeArray<byte> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((byte*)first.GetUnsafePtr(), (byte*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(byte* firstPtr, byte* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(byte)));  
        }

        public static bool SequenceEqual(this NativeList<sbyte> first, NativeList<sbyte> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((sbyte*)first.GetUnsafePtr(), (sbyte*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<sbyte> first, NativeSlice<sbyte> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((sbyte*)first.GetUnsafePtr(), (sbyte*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<sbyte> first, NativeArray<sbyte> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((sbyte*)first.GetUnsafePtr(), (sbyte*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(sbyte* firstPtr, sbyte* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(sbyte)));  
        }

        public static bool SequenceEqual(this NativeList<short> first, NativeList<short> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((short*)first.GetUnsafePtr(), (short*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<short> first, NativeSlice<short> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((short*)first.GetUnsafePtr(), (short*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<short> first, NativeArray<short> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((short*)first.GetUnsafePtr(), (short*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(short* firstPtr, short* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(short)));  
        }

        public static bool SequenceEqual(this NativeList<ushort> first, NativeList<ushort> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((ushort*)first.GetUnsafePtr(), (ushort*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<ushort> first, NativeSlice<ushort> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((ushort*)first.GetUnsafePtr(), (ushort*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<ushort> first, NativeArray<ushort> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((ushort*)first.GetUnsafePtr(), (ushort*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(ushort* firstPtr, ushort* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(ushort)));  
        }

        public static bool SequenceEqual(this NativeList<int> first, NativeList<int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int*)first.GetUnsafePtr(), (int*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<int> first, NativeSlice<int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int*)first.GetUnsafePtr(), (int*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<int> first, NativeArray<int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int*)first.GetUnsafePtr(), (int*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(int* firstPtr, int* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(int)));  
        }

        public static bool SequenceEqual(this NativeList<uint> first, NativeList<uint> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint*)first.GetUnsafePtr(), (uint*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<uint> first, NativeSlice<uint> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint*)first.GetUnsafePtr(), (uint*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<uint> first, NativeArray<uint> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint*)first.GetUnsafePtr(), (uint*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(uint* firstPtr, uint* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(uint)));  
        }

        public static bool SequenceEqual(this NativeList<long> first, NativeList<long> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((long*)first.GetUnsafePtr(), (long*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<long> first, NativeSlice<long> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((long*)first.GetUnsafePtr(), (long*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<long> first, NativeArray<long> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((long*)first.GetUnsafePtr(), (long*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(long* firstPtr, long* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(long)));  
        }

        public static bool SequenceEqual(this NativeList<ulong> first, NativeList<ulong> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((ulong*)first.GetUnsafePtr(), (ulong*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<ulong> first, NativeSlice<ulong> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((ulong*)first.GetUnsafePtr(), (ulong*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<ulong> first, NativeArray<ulong> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((ulong*)first.GetUnsafePtr(), (ulong*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(ulong* firstPtr, ulong* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(ulong)));  
        }

        public static bool SequenceEqual(this NativeList<float> first, NativeList<float> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float*)first.GetUnsafePtr(), (float*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<float> first, NativeSlice<float> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float*)first.GetUnsafePtr(), (float*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<float> first, NativeArray<float> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float*)first.GetUnsafePtr(), (float*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(float* firstPtr, float* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(float) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<double> first, NativeList<double> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double*)first.GetUnsafePtr(), (double*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<double> first, NativeSlice<double> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double*)first.GetUnsafePtr(), (double*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<double> first, NativeArray<double> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double*)first.GetUnsafePtr(), (double*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(double* firstPtr, double* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.DoubleCmp((double*)firstPtr, (double*)secondPtr, length*(sizeof(double) / sizeof(double)));
        }

        public static bool SequenceEqual(this NativeList<Vector2> first, NativeList<Vector2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector2*)first.GetUnsafePtr(), (Vector2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<Vector2> first, NativeSlice<Vector2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector2*)first.GetUnsafePtr(), (Vector2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<Vector2> first, NativeArray<Vector2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector2*)first.GetUnsafePtr(), (Vector2*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(Vector2* firstPtr, Vector2* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(Vector2) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<Vector2Int> first, NativeList<Vector2Int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector2Int*)first.GetUnsafePtr(), (Vector2Int*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<Vector2Int> first, NativeSlice<Vector2Int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector2Int*)first.GetUnsafePtr(), (Vector2Int*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<Vector2Int> first, NativeArray<Vector2Int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector2Int*)first.GetUnsafePtr(), (Vector2Int*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(Vector2Int* firstPtr, Vector2Int* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(Vector2Int)));  
        }

        public static bool SequenceEqual(this NativeList<Vector3> first, NativeList<Vector3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector3*)first.GetUnsafePtr(), (Vector3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<Vector3> first, NativeSlice<Vector3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector3*)first.GetUnsafePtr(), (Vector3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<Vector3> first, NativeArray<Vector3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector3*)first.GetUnsafePtr(), (Vector3*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(Vector3* firstPtr, Vector3* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(Vector3) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<Vector3Int> first, NativeList<Vector3Int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector3Int*)first.GetUnsafePtr(), (Vector3Int*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<Vector3Int> first, NativeSlice<Vector3Int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector3Int*)first.GetUnsafePtr(), (Vector3Int*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<Vector3Int> first, NativeArray<Vector3Int> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector3Int*)first.GetUnsafePtr(), (Vector3Int*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(Vector3Int* firstPtr, Vector3Int* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(Vector3Int)));  
        }

        public static bool SequenceEqual(this NativeList<Vector4> first, NativeList<Vector4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector4*)first.GetUnsafePtr(), (Vector4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<Vector4> first, NativeSlice<Vector4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector4*)first.GetUnsafePtr(), (Vector4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<Vector4> first, NativeArray<Vector4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((Vector4*)first.GetUnsafePtr(), (Vector4*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(Vector4* firstPtr, Vector4* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(Vector4) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<int2> first, NativeList<int2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int2*)first.GetUnsafePtr(), (int2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<int2> first, NativeSlice<int2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int2*)first.GetUnsafePtr(), (int2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<int2> first, NativeArray<int2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int2*)first.GetUnsafePtr(), (int2*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(int2* firstPtr, int2* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(int2)));  
        }

        public static bool SequenceEqual(this NativeList<int3> first, NativeList<int3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int3*)first.GetUnsafePtr(), (int3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<int3> first, NativeSlice<int3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int3*)first.GetUnsafePtr(), (int3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<int3> first, NativeArray<int3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int3*)first.GetUnsafePtr(), (int3*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(int3* firstPtr, int3* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(int3)));  
        }

        public static bool SequenceEqual(this NativeList<int4> first, NativeList<int4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int4*)first.GetUnsafePtr(), (int4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<int4> first, NativeSlice<int4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int4*)first.GetUnsafePtr(), (int4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<int4> first, NativeArray<int4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((int4*)first.GetUnsafePtr(), (int4*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(int4* firstPtr, int4* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(int4)));  
        }

        public static bool SequenceEqual(this NativeList<uint2> first, NativeList<uint2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint2*)first.GetUnsafePtr(), (uint2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<uint2> first, NativeSlice<uint2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint2*)first.GetUnsafePtr(), (uint2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<uint2> first, NativeArray<uint2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint2*)first.GetUnsafePtr(), (uint2*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(uint2* firstPtr, uint2* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(uint2)));  
        }

        public static bool SequenceEqual(this NativeList<uint3> first, NativeList<uint3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint3*)first.GetUnsafePtr(), (uint3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<uint3> first, NativeSlice<uint3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint3*)first.GetUnsafePtr(), (uint3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<uint3> first, NativeArray<uint3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint3*)first.GetUnsafePtr(), (uint3*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(uint3* firstPtr, uint3* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(uint3)));  
        }

        public static bool SequenceEqual(this NativeList<uint4> first, NativeList<uint4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint4*)first.GetUnsafePtr(), (uint4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<uint4> first, NativeSlice<uint4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint4*)first.GetUnsafePtr(), (uint4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<uint4> first, NativeArray<uint4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((uint4*)first.GetUnsafePtr(), (uint4*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(uint4* firstPtr, uint4* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(uint4)));  
        }

        public static bool SequenceEqual(this NativeList<float2> first, NativeList<float2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float2*)first.GetUnsafePtr(), (float2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<float2> first, NativeSlice<float2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float2*)first.GetUnsafePtr(), (float2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<float2> first, NativeArray<float2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float2*)first.GetUnsafePtr(), (float2*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(float2* firstPtr, float2* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(float2) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<float3> first, NativeList<float3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float3*)first.GetUnsafePtr(), (float3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<float3> first, NativeSlice<float3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float3*)first.GetUnsafePtr(), (float3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<float3> first, NativeArray<float3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float3*)first.GetUnsafePtr(), (float3*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(float3* firstPtr, float3* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(float3) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<float4> first, NativeList<float4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float4*)first.GetUnsafePtr(), (float4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<float4> first, NativeSlice<float4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float4*)first.GetUnsafePtr(), (float4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<float4> first, NativeArray<float4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((float4*)first.GetUnsafePtr(), (float4*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(float4* firstPtr, float4* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(float4) / sizeof(float)));
        }

        public static bool SequenceEqual(this NativeList<double2> first, NativeList<double2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double2*)first.GetUnsafePtr(), (double2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<double2> first, NativeSlice<double2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double2*)first.GetUnsafePtr(), (double2*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<double2> first, NativeArray<double2> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double2*)first.GetUnsafePtr(), (double2*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(double2* firstPtr, double2* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.DoubleCmp((double*)firstPtr, (double*)secondPtr, length*(sizeof(double2) / sizeof(double)));
        }

        public static bool SequenceEqual(this NativeList<double3> first, NativeList<double3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double3*)first.GetUnsafePtr(), (double3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<double3> first, NativeSlice<double3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double3*)first.GetUnsafePtr(), (double3*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<double3> first, NativeArray<double3> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double3*)first.GetUnsafePtr(), (double3*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(double3* firstPtr, double3* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.DoubleCmp((double*)firstPtr, (double*)secondPtr, length*(sizeof(double3) / sizeof(double)));
        }

        public static bool SequenceEqual(this NativeList<double4> first, NativeList<double4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double4*)first.GetUnsafePtr(), (double4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<double4> first, NativeSlice<double4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double4*)first.GetUnsafePtr(), (double4*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<double4> first, NativeArray<double4> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((double4*)first.GetUnsafePtr(), (double4*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(double4* firstPtr, double4* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
            return CmpHelpers.DoubleCmp((double*)firstPtr, (double*)secondPtr, length*(sizeof(double4) / sizeof(double)));
        }

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.SequenceEqual.cs.meta
================================================
fileFormatVersion: 2
guid: e0ccd9adadecb4bb7b6683997e98cbe7
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.SequenceEqual.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };

    bool IsFloats(string type)
    {
        return type is "float"  or "float2" or "float3" or "float4"  or "Vector2" or "Vector3" or "Vector4";
    }
    bool IsDoubles(string type)
    {
        return type is  "double" or  "double2" or "double3" or "double4" ;
    }
#>

using System.Runtime.CompilerServices;
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static bool SequenceEqual(this NativeList<<#=type#>> first, NativeList<<#=type#>> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((<#=type#>*)first.GetUnsafePtr(), (<#=type#>*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeSlice<<#=type#>> first, NativeSlice<<#=type#>> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((<#=type#>*)first.GetUnsafePtr(), (<#=type#>*)second.GetUnsafePtr(), first.Length);
        }

        public static bool SequenceEqual(this NativeArray<<#=type#>> first, NativeArray<<#=type#>> second)
        {
            if (first.Length != second.Length) return false;
            return SequenceEqualCore((<#=type#>*)first.GetUnsafePtr(), (<#=type#>*)second.GetUnsafePtr(), first.Length);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal static bool SequenceEqualCore(<#=type#>* firstPtr, <#=type#>* secondPtr, [AssumeRange(0, int.MaxValue)] int length)
        {
<# if (IsFloats(type)){#>
            return CmpHelpers.FloatCmp((float*)firstPtr, (float*)secondPtr, length*(sizeof(<#=type#>) / sizeof(float)));
<# } else if(IsDoubles(type)){#>
            return CmpHelpers.DoubleCmp((double*)firstPtr, (double*)secondPtr, length*(sizeof(<#=type#>) / sizeof(double)));
<# } else{#>
            return CmpHelpers.MemCmp(firstPtr, secondPtr, length * (sizeof(<#=type#>)));  
<# } #>
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.SequenceEqual.tt.meta
================================================
fileFormatVersion: 2
guid: d651c44abf06842ebaaa5b82e3471072
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Sum.cs
================================================
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static int Sum(this NativeList<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int Sum(this NativeSlice<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int Sum(this NativeArray<int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(int* ptr, [AssumeRange(1, int.MaxValue)] int length, out int result)
        {
            var sum = default(int);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static uint Sum(this NativeList<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint Sum(this NativeSlice<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint Sum(this NativeArray<uint> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(uint* ptr, [AssumeRange(1, int.MaxValue)] int length, out uint result)
        {
            var sum = default(uint);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static long Sum(this NativeList<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static long Sum(this NativeSlice<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static long Sum(this NativeArray<long> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((long*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(long* ptr, [AssumeRange(1, int.MaxValue)] int length, out long result)
        {
            var sum = default(long);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static ulong Sum(this NativeList<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ulong Sum(this NativeSlice<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static ulong Sum(this NativeArray<ulong> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((ulong*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(ulong* ptr, [AssumeRange(1, int.MaxValue)] int length, out ulong result)
        {
            var sum = default(ulong);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static float Sum(this NativeList<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Sum(this NativeSlice<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float Sum(this NativeArray<float> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(float* ptr, [AssumeRange(1, int.MaxValue)] int length, out float result)
        {
            var sum = default(float);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static double Sum(this NativeList<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Sum(this NativeSlice<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double Sum(this NativeArray<double> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(double* ptr, [AssumeRange(1, int.MaxValue)] int length, out double result)
        {
            var sum = default(double);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static Vector2 Sum(this NativeList<Vector2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2 Sum(this NativeSlice<Vector2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2 Sum(this NativeArray<Vector2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(Vector2* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector2 result)
        {
            SumCore((float4*)ptr, length / 2, out var sum2);
            var sum = new Vector2(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }

        public static Vector2Int Sum(this NativeList<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector2Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2Int Sum(this NativeSlice<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector2Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector2Int Sum(this NativeArray<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector2Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(Vector2Int* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector2Int result)
        {
            SumCore((int4*)ptr, length / 2, out var sum2);
            var sum = new Vector2Int(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }

        public static Vector3 Sum(this NativeList<Vector3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3 Sum(this NativeSlice<Vector3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3 Sum(this NativeArray<Vector3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(Vector3* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector3 result)
        {
            var sum = default(Vector3);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static Vector3Int Sum(this NativeList<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector3Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3Int Sum(this NativeSlice<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector3Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector3Int Sum(this NativeArray<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector3Int*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(Vector3Int* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector3Int result)
        {
            var sum = default(Vector3Int);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static Vector4 Sum(this NativeList<Vector4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector4 Sum(this NativeSlice<Vector4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static Vector4 Sum(this NativeArray<Vector4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((Vector4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(Vector4* ptr, [AssumeRange(1, int.MaxValue)] int length, out Vector4 result)
        {
            var sum = default(Vector4);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static int2 Sum(this NativeList<int2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int2 Sum(this NativeSlice<int2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int2 Sum(this NativeArray<int2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(int2* ptr, [AssumeRange(1, int.MaxValue)] int length, out int2 result)
        {
            SumCore((int4*)ptr, length / 2, out var sum2);
            var sum = new int2(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }

        public static int3 Sum(this NativeList<int3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int3 Sum(this NativeSlice<int3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int3 Sum(this NativeArray<int3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(int3* ptr, [AssumeRange(1, int.MaxValue)] int length, out int3 result)
        {
            var sum = default(int3);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static int4 Sum(this NativeList<int4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int4 Sum(this NativeSlice<int4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static int4 Sum(this NativeArray<int4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((int4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(int4* ptr, [AssumeRange(1, int.MaxValue)] int length, out int4 result)
        {
            var sum = default(int4);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static uint2 Sum(this NativeList<uint2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint2 Sum(this NativeSlice<uint2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint2 Sum(this NativeArray<uint2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(uint2* ptr, [AssumeRange(1, int.MaxValue)] int length, out uint2 result)
        {
            SumCore((uint4*)ptr, length / 2, out var sum2);
            var sum = new uint2(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }

        public static uint3 Sum(this NativeList<uint3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint3 Sum(this NativeSlice<uint3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint3 Sum(this NativeArray<uint3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(uint3* ptr, [AssumeRange(1, int.MaxValue)] int length, out uint3 result)
        {
            var sum = default(uint3);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static uint4 Sum(this NativeList<uint4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint4 Sum(this NativeSlice<uint4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static uint4 Sum(this NativeArray<uint4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((uint4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(uint4* ptr, [AssumeRange(1, int.MaxValue)] int length, out uint4 result)
        {
            var sum = default(uint4);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static float2 Sum(this NativeList<float2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float2 Sum(this NativeSlice<float2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float2 Sum(this NativeArray<float2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(float2* ptr, [AssumeRange(1, int.MaxValue)] int length, out float2 result)
        {
            SumCore((float4*)ptr, length / 2, out var sum2);
            var sum = new float2(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }

        public static float3 Sum(this NativeList<float3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float3 Sum(this NativeSlice<float3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float3 Sum(this NativeArray<float3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(float3* ptr, [AssumeRange(1, int.MaxValue)] int length, out float3 result)
        {
            var sum = default(float3);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static float4 Sum(this NativeList<float4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float4 Sum(this NativeSlice<float4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static float4 Sum(this NativeArray<float4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((float4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(float4* ptr, [AssumeRange(1, int.MaxValue)] int length, out float4 result)
        {
            var sum = default(float4);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static double2 Sum(this NativeList<double2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double2 Sum(this NativeSlice<double2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double2 Sum(this NativeArray<double2> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double2*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(double2* ptr, [AssumeRange(1, int.MaxValue)] int length, out double2 result)
        {
            SumCore((double4*)ptr, length / 2, out var sum2);
            var sum = new double2(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }

        public static double3 Sum(this NativeList<double3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double3 Sum(this NativeSlice<double3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double3 Sum(this NativeArray<double3> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double3*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(double3* ptr, [AssumeRange(1, int.MaxValue)] int length, out double3 result)
        {
            var sum = default(double3);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

        public static double4 Sum(this NativeList<double4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double4 Sum(this NativeSlice<double4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static double4 Sum(this NativeArray<double4> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((double4*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(double4* ptr, [AssumeRange(1, int.MaxValue)] int length, out double4 result)
        {
            var sum = default(double4);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Sum.cs.meta
================================================
fileFormatVersion: 2
guid: 714495b51e8264155bb1ccf1c6283ebb
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Sum.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };

    bool TryGetTwiceVector(string type, out string longer)
    {
        longer = null;
        switch (type)
        {
            case "int2": longer = "int4"; return true;
            case "uint2": longer = "uint4"; return true;
            case "float2": longer = "float4"; return true;
            case "double2": longer = "double4"; return true;
            case "Vector2": longer = "float4"; return true;
            case "Vector2Int": longer = "int4"; return true;
            default: return false;
        }
    }
    
#>
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=type#> Sum(this NativeList<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=type#> Sum(this NativeSlice<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

        public static <#=type#> Sum(this NativeArray<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.Length);
            SumCore((<#=type#>*)source.GetUnsafePtr(), source.Length, out var result);
            return result;
        }

<#if (TryGetTwiceVector(type, out var twiceType)) { #>
        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, out <#=type#> result)
        {
            SumCore((<#=twiceType#>*)ptr, length / 2, out var sum2);
            var sum = new <#=type#>(sum2.x + sum2.z, sum2.y + sum2.w);
            if (length % 2 == 1) sum += ptr[length - 1];
            result = sum;
        }
<# } else { #>
        [BurstCompile(FloatMode = FloatMode.Fast)]
        internal static void SumCore(<#=type#>* ptr, [AssumeRange(1, int.MaxValue)] int length, out <#=type#> result)
        {
            var sum = default(<#=type#>);
            for (int i = 0; i < length; i++) sum += ptr[i];
            result = sum;
        }
<# } #>

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Native.Sum.tt.meta
================================================
fileFormatVersion: 2
guid: 1cdd06228afb942f78b23c4dca6c4e47
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.SequenceEqual.cs
================================================
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static bool SequenceEqual(this byte[] first, byte[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (byte* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this byte[] first, List<byte> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (byte* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this byte[] first, Memory<byte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<byte>)second.Span);
        }

        public static bool SequenceEqual(this byte[] first, ReadOnlyMemory<byte> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this byte[] first, Span<byte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<byte>)second);
        }

        public static bool SequenceEqual(this byte[] first, ReadOnlySpan<byte> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (byte* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<byte> first, byte[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<byte> first, List<byte> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (byte* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<byte> first, Memory<byte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<byte>)second.Span);
        }

        public static bool SequenceEqual(this List<byte> first, ReadOnlyMemory<byte> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<byte> first, Span<byte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<byte>)second);
        }

        public static bool SequenceEqual(this List<byte> first, ReadOnlySpan<byte> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (byte* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<byte> first, Memory<byte> second)
        {
            return SequenceEqual((ReadOnlySpan<byte>)first.Span, (ReadOnlySpan<byte>)second.Span);
        }

        public static bool SequenceEqual(this Memory<byte> first, ReadOnlyMemory<byte> second)
        {
            return SequenceEqual((ReadOnlySpan<byte>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<byte> first, ReadOnlyMemory<byte> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<byte> first, Span<byte> second)
        {
            return SequenceEqual((ReadOnlySpan<byte>)first, (ReadOnlySpan<byte>)second);
        }

        public static bool SequenceEqual(this Span<byte> first, ReadOnlySpan<byte> second)
        {
            return SequenceEqual((ReadOnlySpan<byte>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<byte> first, ReadOnlySpan<byte> second)
        {
            if (first.Length != second.Length) return false;

            fixed (byte* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this sbyte[] first, sbyte[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (sbyte* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this sbyte[] first, List<sbyte> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (sbyte* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this sbyte[] first, Memory<sbyte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<sbyte>)second.Span);
        }

        public static bool SequenceEqual(this sbyte[] first, ReadOnlyMemory<sbyte> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this sbyte[] first, Span<sbyte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<sbyte>)second);
        }

        public static bool SequenceEqual(this sbyte[] first, ReadOnlySpan<sbyte> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (sbyte* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<sbyte> first, sbyte[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<sbyte> first, List<sbyte> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (sbyte* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<sbyte> first, Memory<sbyte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<sbyte>)second.Span);
        }

        public static bool SequenceEqual(this List<sbyte> first, ReadOnlyMemory<sbyte> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<sbyte> first, Span<sbyte> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<sbyte>)second);
        }

        public static bool SequenceEqual(this List<sbyte> first, ReadOnlySpan<sbyte> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (sbyte* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<sbyte> first, Memory<sbyte> second)
        {
            return SequenceEqual((ReadOnlySpan<sbyte>)first.Span, (ReadOnlySpan<sbyte>)second.Span);
        }

        public static bool SequenceEqual(this Memory<sbyte> first, ReadOnlyMemory<sbyte> second)
        {
            return SequenceEqual((ReadOnlySpan<sbyte>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<sbyte> first, ReadOnlyMemory<sbyte> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<sbyte> first, Span<sbyte> second)
        {
            return SequenceEqual((ReadOnlySpan<sbyte>)first, (ReadOnlySpan<sbyte>)second);
        }

        public static bool SequenceEqual(this Span<sbyte> first, ReadOnlySpan<sbyte> second)
        {
            return SequenceEqual((ReadOnlySpan<sbyte>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<sbyte> first, ReadOnlySpan<sbyte> second)
        {
            if (first.Length != second.Length) return false;

            fixed (sbyte* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this short[] first, short[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (short* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this short[] first, List<short> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (short* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this short[] first, Memory<short> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<short>)second.Span);
        }

        public static bool SequenceEqual(this short[] first, ReadOnlyMemory<short> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this short[] first, Span<short> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<short>)second);
        }

        public static bool SequenceEqual(this short[] first, ReadOnlySpan<short> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (short* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<short> first, short[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<short> first, List<short> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (short* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<short> first, Memory<short> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<short>)second.Span);
        }

        public static bool SequenceEqual(this List<short> first, ReadOnlyMemory<short> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<short> first, Span<short> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<short>)second);
        }

        public static bool SequenceEqual(this List<short> first, ReadOnlySpan<short> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (short* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<short> first, Memory<short> second)
        {
            return SequenceEqual((ReadOnlySpan<short>)first.Span, (ReadOnlySpan<short>)second.Span);
        }

        public static bool SequenceEqual(this Memory<short> first, ReadOnlyMemory<short> second)
        {
            return SequenceEqual((ReadOnlySpan<short>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<short> first, ReadOnlyMemory<short> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<short> first, Span<short> second)
        {
            return SequenceEqual((ReadOnlySpan<short>)first, (ReadOnlySpan<short>)second);
        }

        public static bool SequenceEqual(this Span<short> first, ReadOnlySpan<short> second)
        {
            return SequenceEqual((ReadOnlySpan<short>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<short> first, ReadOnlySpan<short> second)
        {
            if (first.Length != second.Length) return false;

            fixed (short* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this ushort[] first, ushort[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (ushort* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this ushort[] first, List<ushort> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (ushort* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this ushort[] first, Memory<ushort> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ushort>)second.Span);
        }

        public static bool SequenceEqual(this ushort[] first, ReadOnlyMemory<ushort> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this ushort[] first, Span<ushort> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ushort>)second);
        }

        public static bool SequenceEqual(this ushort[] first, ReadOnlySpan<ushort> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (ushort* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<ushort> first, ushort[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<ushort> first, List<ushort> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (ushort* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<ushort> first, Memory<ushort> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ushort>)second.Span);
        }

        public static bool SequenceEqual(this List<ushort> first, ReadOnlyMemory<ushort> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<ushort> first, Span<ushort> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ushort>)second);
        }

        public static bool SequenceEqual(this List<ushort> first, ReadOnlySpan<ushort> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (ushort* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<ushort> first, Memory<ushort> second)
        {
            return SequenceEqual((ReadOnlySpan<ushort>)first.Span, (ReadOnlySpan<ushort>)second.Span);
        }

        public static bool SequenceEqual(this Memory<ushort> first, ReadOnlyMemory<ushort> second)
        {
            return SequenceEqual((ReadOnlySpan<ushort>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<ushort> first, ReadOnlyMemory<ushort> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<ushort> first, Span<ushort> second)
        {
            return SequenceEqual((ReadOnlySpan<ushort>)first, (ReadOnlySpan<ushort>)second);
        }

        public static bool SequenceEqual(this Span<ushort> first, ReadOnlySpan<ushort> second)
        {
            return SequenceEqual((ReadOnlySpan<ushort>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<ushort> first, ReadOnlySpan<ushort> second)
        {
            if (first.Length != second.Length) return false;

            fixed (ushort* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this int[] first, int[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;
            fixed (int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int[] first, List<int> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int[] first, Memory<int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int>)second.Span);
        }

        public static bool SequenceEqual(this int[] first, ReadOnlyMemory<int> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this int[] first, Span<int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int>)second);
        }

        public static bool SequenceEqual(this int[] first, ReadOnlySpan<int> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<int> first, int[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<int> first, List<int> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<int> first, Memory<int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int>)second.Span);
        }

        public static bool SequenceEqual(this List<int> first, ReadOnlyMemory<int> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<int> first, Span<int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int>)second);
        }

        public static bool SequenceEqual(this List<int> first, ReadOnlySpan<int> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (int* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<int> first, Memory<int> second)
        {
            return SequenceEqual((ReadOnlySpan<int>)first.Span, (ReadOnlySpan<int>)second.Span);
        }

        public static bool SequenceEqual(this Memory<int> first, ReadOnlyMemory<int> second)
        {
            return SequenceEqual((ReadOnlySpan<int>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<int> first, ReadOnlyMemory<int> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<int> first, Span<int> second)
        {
            return SequenceEqual((ReadOnlySpan<int>)first, (ReadOnlySpan<int>)second);
        }

        public static bool SequenceEqual(this Span<int> first, ReadOnlySpan<int> second)
        {
            return SequenceEqual((ReadOnlySpan<int>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<int> first, ReadOnlySpan<int> second)
        {
            if (first.Length != second.Length) return false;

            fixed (int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this uint[] first, uint[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (uint* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint[] first, List<uint> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint[] first, Memory<uint> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint>)second.Span);
        }

        public static bool SequenceEqual(this uint[] first, ReadOnlyMemory<uint> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this uint[] first, Span<uint> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint>)second);
        }

        public static bool SequenceEqual(this uint[] first, ReadOnlySpan<uint> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (uint* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<uint> first, uint[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<uint> first, List<uint> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<uint> first, Memory<uint> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint>)second.Span);
        }

        public static bool SequenceEqual(this List<uint> first, ReadOnlyMemory<uint> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<uint> first, Span<uint> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint>)second);
        }

        public static bool SequenceEqual(this List<uint> first, ReadOnlySpan<uint> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (uint* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<uint> first, Memory<uint> second)
        {
            return SequenceEqual((ReadOnlySpan<uint>)first.Span, (ReadOnlySpan<uint>)second.Span);
        }

        public static bool SequenceEqual(this Memory<uint> first, ReadOnlyMemory<uint> second)
        {
            return SequenceEqual((ReadOnlySpan<uint>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<uint> first, ReadOnlyMemory<uint> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<uint> first, Span<uint> second)
        {
            return SequenceEqual((ReadOnlySpan<uint>)first, (ReadOnlySpan<uint>)second);
        }

        public static bool SequenceEqual(this Span<uint> first, ReadOnlySpan<uint> second)
        {
            return SequenceEqual((ReadOnlySpan<uint>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<uint> first, ReadOnlySpan<uint> second)
        {
            if (first.Length != second.Length) return false;

            fixed (uint* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this long[] first, long[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (long* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this long[] first, List<long> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (long* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this long[] first, Memory<long> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<long>)second.Span);
        }

        public static bool SequenceEqual(this long[] first, ReadOnlyMemory<long> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this long[] first, Span<long> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<long>)second);
        }

        public static bool SequenceEqual(this long[] first, ReadOnlySpan<long> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (long* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<long> first, long[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<long> first, List<long> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (long* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<long> first, Memory<long> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<long>)second.Span);
        }

        public static bool SequenceEqual(this List<long> first, ReadOnlyMemory<long> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<long> first, Span<long> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<long>)second);
        }

        public static bool SequenceEqual(this List<long> first, ReadOnlySpan<long> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (long* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<long> first, Memory<long> second)
        {
            return SequenceEqual((ReadOnlySpan<long>)first.Span, (ReadOnlySpan<long>)second.Span);
        }

        public static bool SequenceEqual(this Memory<long> first, ReadOnlyMemory<long> second)
        {
            return SequenceEqual((ReadOnlySpan<long>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<long> first, ReadOnlyMemory<long> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<long> first, Span<long> second)
        {
            return SequenceEqual((ReadOnlySpan<long>)first, (ReadOnlySpan<long>)second);
        }

        public static bool SequenceEqual(this Span<long> first, ReadOnlySpan<long> second)
        {
            return SequenceEqual((ReadOnlySpan<long>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<long> first, ReadOnlySpan<long> second)
        {
            if (first.Length != second.Length) return false;

            fixed (long* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this ulong[] first, ulong[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (ulong* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this ulong[] first, List<ulong> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (ulong* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this ulong[] first, Memory<ulong> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ulong>)second.Span);
        }

        public static bool SequenceEqual(this ulong[] first, ReadOnlyMemory<ulong> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this ulong[] first, Span<ulong> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ulong>)second);
        }

        public static bool SequenceEqual(this ulong[] first, ReadOnlySpan<ulong> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (ulong* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<ulong> first, ulong[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<ulong> first, List<ulong> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (ulong* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<ulong> first, Memory<ulong> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ulong>)second.Span);
        }

        public static bool SequenceEqual(this List<ulong> first, ReadOnlyMemory<ulong> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<ulong> first, Span<ulong> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<ulong>)second);
        }

        public static bool SequenceEqual(this List<ulong> first, ReadOnlySpan<ulong> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (ulong* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<ulong> first, Memory<ulong> second)
        {
            return SequenceEqual((ReadOnlySpan<ulong>)first.Span, (ReadOnlySpan<ulong>)second.Span);
        }

        public static bool SequenceEqual(this Memory<ulong> first, ReadOnlyMemory<ulong> second)
        {
            return SequenceEqual((ReadOnlySpan<ulong>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<ulong> first, ReadOnlyMemory<ulong> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<ulong> first, Span<ulong> second)
        {
            return SequenceEqual((ReadOnlySpan<ulong>)first, (ReadOnlySpan<ulong>)second);
        }

        public static bool SequenceEqual(this Span<ulong> first, ReadOnlySpan<ulong> second)
        {
            return SequenceEqual((ReadOnlySpan<ulong>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<ulong> first, ReadOnlySpan<ulong> second)
        {
            if (first.Length != second.Length) return false;

            fixed (ulong* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this float[] first, float[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (float* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float[] first, List<float> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float[] first, Memory<float> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float>)second.Span);
        }

        public static bool SequenceEqual(this float[] first, ReadOnlyMemory<float> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this float[] first, Span<float> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float>)second);
        }

        public static bool SequenceEqual(this float[] first, ReadOnlySpan<float> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (float* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<float> first, float[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<float> first, List<float> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<float> first, Memory<float> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float>)second.Span);
        }

        public static bool SequenceEqual(this List<float> first, ReadOnlyMemory<float> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<float> first, Span<float> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float>)second);
        }

        public static bool SequenceEqual(this List<float> first, ReadOnlySpan<float> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (float* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<float> first, Memory<float> second)
        {
            return SequenceEqual((ReadOnlySpan<float>)first.Span, (ReadOnlySpan<float>)second.Span);
        }

        public static bool SequenceEqual(this Memory<float> first, ReadOnlyMemory<float> second)
        {
            return SequenceEqual((ReadOnlySpan<float>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<float> first, ReadOnlyMemory<float> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<float> first, Span<float> second)
        {
            return SequenceEqual((ReadOnlySpan<float>)first, (ReadOnlySpan<float>)second);
        }

        public static bool SequenceEqual(this Span<float> first, ReadOnlySpan<float> second)
        {
            return SequenceEqual((ReadOnlySpan<float>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<float> first, ReadOnlySpan<float> second)
        {
            if (first.Length != second.Length) return false;

            fixed (float* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this double[] first, double[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (double* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double[] first, List<double> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double[] first, Memory<double> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double>)second.Span);
        }

        public static bool SequenceEqual(this double[] first, ReadOnlyMemory<double> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this double[] first, Span<double> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double>)second);
        }

        public static bool SequenceEqual(this double[] first, ReadOnlySpan<double> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (double* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<double> first, double[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<double> first, List<double> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<double> first, Memory<double> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double>)second.Span);
        }

        public static bool SequenceEqual(this List<double> first, ReadOnlyMemory<double> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<double> first, Span<double> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double>)second);
        }

        public static bool SequenceEqual(this List<double> first, ReadOnlySpan<double> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (double* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<double> first, Memory<double> second)
        {
            return SequenceEqual((ReadOnlySpan<double>)first.Span, (ReadOnlySpan<double>)second.Span);
        }

        public static bool SequenceEqual(this Memory<double> first, ReadOnlyMemory<double> second)
        {
            return SequenceEqual((ReadOnlySpan<double>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<double> first, ReadOnlyMemory<double> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<double> first, Span<double> second)
        {
            return SequenceEqual((ReadOnlySpan<double>)first, (ReadOnlySpan<double>)second);
        }

        public static bool SequenceEqual(this Span<double> first, ReadOnlySpan<double> second)
        {
            return SequenceEqual((ReadOnlySpan<double>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<double> first, ReadOnlySpan<double> second)
        {
            if (first.Length != second.Length) return false;

            fixed (double* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this Vector2[] first, Vector2[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (Vector2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector2[] first, List<Vector2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector2* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector2[] first, Memory<Vector2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2>)second.Span);
        }

        public static bool SequenceEqual(this Vector2[] first, ReadOnlyMemory<Vector2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this Vector2[] first, Span<Vector2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2>)second);
        }

        public static bool SequenceEqual(this Vector2[] first, ReadOnlySpan<Vector2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (Vector2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<Vector2> first, Vector2[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<Vector2> first, List<Vector2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector2* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<Vector2> first, Memory<Vector2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2>)second.Span);
        }

        public static bool SequenceEqual(this List<Vector2> first, ReadOnlyMemory<Vector2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<Vector2> first, Span<Vector2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2>)second);
        }

        public static bool SequenceEqual(this List<Vector2> first, ReadOnlySpan<Vector2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (Vector2* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<Vector2> first, Memory<Vector2> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2>)first.Span, (ReadOnlySpan<Vector2>)second.Span);
        }

        public static bool SequenceEqual(this Memory<Vector2> first, ReadOnlyMemory<Vector2> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<Vector2> first, ReadOnlyMemory<Vector2> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<Vector2> first, Span<Vector2> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2>)first, (ReadOnlySpan<Vector2>)second);
        }

        public static bool SequenceEqual(this Span<Vector2> first, ReadOnlySpan<Vector2> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<Vector2> first, ReadOnlySpan<Vector2> second)
        {
            if (first.Length != second.Length) return false;

            fixed (Vector2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this Vector2Int[] first, Vector2Int[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (Vector2Int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector2Int[] first, List<Vector2Int> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector2Int* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector2Int[] first, Memory<Vector2Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2Int>)second.Span);
        }

        public static bool SequenceEqual(this Vector2Int[] first, ReadOnlyMemory<Vector2Int> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this Vector2Int[] first, Span<Vector2Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2Int>)second);
        }

        public static bool SequenceEqual(this Vector2Int[] first, ReadOnlySpan<Vector2Int> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (Vector2Int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<Vector2Int> first, Vector2Int[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<Vector2Int> first, List<Vector2Int> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector2Int* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<Vector2Int> first, Memory<Vector2Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2Int>)second.Span);
        }

        public static bool SequenceEqual(this List<Vector2Int> first, ReadOnlyMemory<Vector2Int> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<Vector2Int> first, Span<Vector2Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector2Int>)second);
        }

        public static bool SequenceEqual(this List<Vector2Int> first, ReadOnlySpan<Vector2Int> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (Vector2Int* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<Vector2Int> first, Memory<Vector2Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2Int>)first.Span, (ReadOnlySpan<Vector2Int>)second.Span);
        }

        public static bool SequenceEqual(this Memory<Vector2Int> first, ReadOnlyMemory<Vector2Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2Int>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<Vector2Int> first, ReadOnlyMemory<Vector2Int> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<Vector2Int> first, Span<Vector2Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2Int>)first, (ReadOnlySpan<Vector2Int>)second);
        }

        public static bool SequenceEqual(this Span<Vector2Int> first, ReadOnlySpan<Vector2Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector2Int>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<Vector2Int> first, ReadOnlySpan<Vector2Int> second)
        {
            if (first.Length != second.Length) return false;

            fixed (Vector2Int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this Vector3[] first, Vector3[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (Vector3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector3[] first, List<Vector3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector3* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector3[] first, Memory<Vector3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3>)second.Span);
        }

        public static bool SequenceEqual(this Vector3[] first, ReadOnlyMemory<Vector3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this Vector3[] first, Span<Vector3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3>)second);
        }

        public static bool SequenceEqual(this Vector3[] first, ReadOnlySpan<Vector3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (Vector3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<Vector3> first, Vector3[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<Vector3> first, List<Vector3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector3* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<Vector3> first, Memory<Vector3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3>)second.Span);
        }

        public static bool SequenceEqual(this List<Vector3> first, ReadOnlyMemory<Vector3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<Vector3> first, Span<Vector3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3>)second);
        }

        public static bool SequenceEqual(this List<Vector3> first, ReadOnlySpan<Vector3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (Vector3* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<Vector3> first, Memory<Vector3> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3>)first.Span, (ReadOnlySpan<Vector3>)second.Span);
        }

        public static bool SequenceEqual(this Memory<Vector3> first, ReadOnlyMemory<Vector3> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<Vector3> first, ReadOnlyMemory<Vector3> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<Vector3> first, Span<Vector3> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3>)first, (ReadOnlySpan<Vector3>)second);
        }

        public static bool SequenceEqual(this Span<Vector3> first, ReadOnlySpan<Vector3> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<Vector3> first, ReadOnlySpan<Vector3> second)
        {
            if (first.Length != second.Length) return false;

            fixed (Vector3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this Vector3Int[] first, Vector3Int[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (Vector3Int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector3Int[] first, List<Vector3Int> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector3Int* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector3Int[] first, Memory<Vector3Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3Int>)second.Span);
        }

        public static bool SequenceEqual(this Vector3Int[] first, ReadOnlyMemory<Vector3Int> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this Vector3Int[] first, Span<Vector3Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3Int>)second);
        }

        public static bool SequenceEqual(this Vector3Int[] first, ReadOnlySpan<Vector3Int> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (Vector3Int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<Vector3Int> first, Vector3Int[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<Vector3Int> first, List<Vector3Int> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector3Int* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<Vector3Int> first, Memory<Vector3Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3Int>)second.Span);
        }

        public static bool SequenceEqual(this List<Vector3Int> first, ReadOnlyMemory<Vector3Int> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<Vector3Int> first, Span<Vector3Int> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector3Int>)second);
        }

        public static bool SequenceEqual(this List<Vector3Int> first, ReadOnlySpan<Vector3Int> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (Vector3Int* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<Vector3Int> first, Memory<Vector3Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3Int>)first.Span, (ReadOnlySpan<Vector3Int>)second.Span);
        }

        public static bool SequenceEqual(this Memory<Vector3Int> first, ReadOnlyMemory<Vector3Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3Int>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<Vector3Int> first, ReadOnlyMemory<Vector3Int> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<Vector3Int> first, Span<Vector3Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3Int>)first, (ReadOnlySpan<Vector3Int>)second);
        }

        public static bool SequenceEqual(this Span<Vector3Int> first, ReadOnlySpan<Vector3Int> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector3Int>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<Vector3Int> first, ReadOnlySpan<Vector3Int> second)
        {
            if (first.Length != second.Length) return false;

            fixed (Vector3Int* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this Vector4[] first, Vector4[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (Vector4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector4[] first, List<Vector4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector4* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this Vector4[] first, Memory<Vector4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector4>)second.Span);
        }

        public static bool SequenceEqual(this Vector4[] first, ReadOnlyMemory<Vector4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this Vector4[] first, Span<Vector4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector4>)second);
        }

        public static bool SequenceEqual(this Vector4[] first, ReadOnlySpan<Vector4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (Vector4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<Vector4> first, Vector4[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<Vector4> first, List<Vector4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (Vector4* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<Vector4> first, Memory<Vector4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector4>)second.Span);
        }

        public static bool SequenceEqual(this List<Vector4> first, ReadOnlyMemory<Vector4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<Vector4> first, Span<Vector4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<Vector4>)second);
        }

        public static bool SequenceEqual(this List<Vector4> first, ReadOnlySpan<Vector4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (Vector4* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<Vector4> first, Memory<Vector4> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector4>)first.Span, (ReadOnlySpan<Vector4>)second.Span);
        }

        public static bool SequenceEqual(this Memory<Vector4> first, ReadOnlyMemory<Vector4> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector4>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<Vector4> first, ReadOnlyMemory<Vector4> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<Vector4> first, Span<Vector4> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector4>)first, (ReadOnlySpan<Vector4>)second);
        }

        public static bool SequenceEqual(this Span<Vector4> first, ReadOnlySpan<Vector4> second)
        {
            return SequenceEqual((ReadOnlySpan<Vector4>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<Vector4> first, ReadOnlySpan<Vector4> second)
        {
            if (first.Length != second.Length) return false;

            fixed (Vector4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this int2[] first, int2[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (int2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int2[] first, List<int2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int2* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int2[] first, Memory<int2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int2>)second.Span);
        }

        public static bool SequenceEqual(this int2[] first, ReadOnlyMemory<int2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this int2[] first, Span<int2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int2>)second);
        }

        public static bool SequenceEqual(this int2[] first, ReadOnlySpan<int2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (int2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<int2> first, int2[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<int2> first, List<int2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int2* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<int2> first, Memory<int2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int2>)second.Span);
        }

        public static bool SequenceEqual(this List<int2> first, ReadOnlyMemory<int2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<int2> first, Span<int2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int2>)second);
        }

        public static bool SequenceEqual(this List<int2> first, ReadOnlySpan<int2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (int2* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<int2> first, Memory<int2> second)
        {
            return SequenceEqual((ReadOnlySpan<int2>)first.Span, (ReadOnlySpan<int2>)second.Span);
        }

        public static bool SequenceEqual(this Memory<int2> first, ReadOnlyMemory<int2> second)
        {
            return SequenceEqual((ReadOnlySpan<int2>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<int2> first, ReadOnlyMemory<int2> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<int2> first, Span<int2> second)
        {
            return SequenceEqual((ReadOnlySpan<int2>)first, (ReadOnlySpan<int2>)second);
        }

        public static bool SequenceEqual(this Span<int2> first, ReadOnlySpan<int2> second)
        {
            return SequenceEqual((ReadOnlySpan<int2>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<int2> first, ReadOnlySpan<int2> second)
        {
            if (first.Length != second.Length) return false;

            fixed (int2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this int3[] first, int3[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (int3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int3[] first, List<int3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int3* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int3[] first, Memory<int3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int3>)second.Span);
        }

        public static bool SequenceEqual(this int3[] first, ReadOnlyMemory<int3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this int3[] first, Span<int3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int3>)second);
        }

        public static bool SequenceEqual(this int3[] first, ReadOnlySpan<int3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (int3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<int3> first, int3[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<int3> first, List<int3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int3* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<int3> first, Memory<int3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int3>)second.Span);
        }

        public static bool SequenceEqual(this List<int3> first, ReadOnlyMemory<int3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<int3> first, Span<int3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int3>)second);
        }

        public static bool SequenceEqual(this List<int3> first, ReadOnlySpan<int3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (int3* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<int3> first, Memory<int3> second)
        {
            return SequenceEqual((ReadOnlySpan<int3>)first.Span, (ReadOnlySpan<int3>)second.Span);
        }

        public static bool SequenceEqual(this Memory<int3> first, ReadOnlyMemory<int3> second)
        {
            return SequenceEqual((ReadOnlySpan<int3>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<int3> first, ReadOnlyMemory<int3> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<int3> first, Span<int3> second)
        {
            return SequenceEqual((ReadOnlySpan<int3>)first, (ReadOnlySpan<int3>)second);
        }

        public static bool SequenceEqual(this Span<int3> first, ReadOnlySpan<int3> second)
        {
            return SequenceEqual((ReadOnlySpan<int3>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<int3> first, ReadOnlySpan<int3> second)
        {
            if (first.Length != second.Length) return false;

            fixed (int3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this int4[] first, int4[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (int4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int4[] first, List<int4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int4* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this int4[] first, Memory<int4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int4>)second.Span);
        }

        public static bool SequenceEqual(this int4[] first, ReadOnlyMemory<int4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this int4[] first, Span<int4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int4>)second);
        }

        public static bool SequenceEqual(this int4[] first, ReadOnlySpan<int4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (int4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<int4> first, int4[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<int4> first, List<int4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (int4* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<int4> first, Memory<int4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int4>)second.Span);
        }

        public static bool SequenceEqual(this List<int4> first, ReadOnlyMemory<int4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<int4> first, Span<int4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<int4>)second);
        }

        public static bool SequenceEqual(this List<int4> first, ReadOnlySpan<int4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (int4* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<int4> first, Memory<int4> second)
        {
            return SequenceEqual((ReadOnlySpan<int4>)first.Span, (ReadOnlySpan<int4>)second.Span);
        }

        public static bool SequenceEqual(this Memory<int4> first, ReadOnlyMemory<int4> second)
        {
            return SequenceEqual((ReadOnlySpan<int4>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<int4> first, ReadOnlyMemory<int4> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<int4> first, Span<int4> second)
        {
            return SequenceEqual((ReadOnlySpan<int4>)first, (ReadOnlySpan<int4>)second);
        }

        public static bool SequenceEqual(this Span<int4> first, ReadOnlySpan<int4> second)
        {
            return SequenceEqual((ReadOnlySpan<int4>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<int4> first, ReadOnlySpan<int4> second)
        {
            if (first.Length != second.Length) return false;

            fixed (int4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this uint2[] first, uint2[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (uint2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint2[] first, List<uint2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint2* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint2[] first, Memory<uint2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint2>)second.Span);
        }

        public static bool SequenceEqual(this uint2[] first, ReadOnlyMemory<uint2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this uint2[] first, Span<uint2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint2>)second);
        }

        public static bool SequenceEqual(this uint2[] first, ReadOnlySpan<uint2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (uint2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<uint2> first, uint2[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<uint2> first, List<uint2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint2* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<uint2> first, Memory<uint2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint2>)second.Span);
        }

        public static bool SequenceEqual(this List<uint2> first, ReadOnlyMemory<uint2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<uint2> first, Span<uint2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint2>)second);
        }

        public static bool SequenceEqual(this List<uint2> first, ReadOnlySpan<uint2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (uint2* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<uint2> first, Memory<uint2> second)
        {
            return SequenceEqual((ReadOnlySpan<uint2>)first.Span, (ReadOnlySpan<uint2>)second.Span);
        }

        public static bool SequenceEqual(this Memory<uint2> first, ReadOnlyMemory<uint2> second)
        {
            return SequenceEqual((ReadOnlySpan<uint2>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<uint2> first, ReadOnlyMemory<uint2> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<uint2> first, Span<uint2> second)
        {
            return SequenceEqual((ReadOnlySpan<uint2>)first, (ReadOnlySpan<uint2>)second);
        }

        public static bool SequenceEqual(this Span<uint2> first, ReadOnlySpan<uint2> second)
        {
            return SequenceEqual((ReadOnlySpan<uint2>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<uint2> first, ReadOnlySpan<uint2> second)
        {
            if (first.Length != second.Length) return false;

            fixed (uint2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this uint3[] first, uint3[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (uint3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint3[] first, List<uint3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint3* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint3[] first, Memory<uint3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint3>)second.Span);
        }

        public static bool SequenceEqual(this uint3[] first, ReadOnlyMemory<uint3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this uint3[] first, Span<uint3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint3>)second);
        }

        public static bool SequenceEqual(this uint3[] first, ReadOnlySpan<uint3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (uint3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<uint3> first, uint3[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<uint3> first, List<uint3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint3* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<uint3> first, Memory<uint3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint3>)second.Span);
        }

        public static bool SequenceEqual(this List<uint3> first, ReadOnlyMemory<uint3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<uint3> first, Span<uint3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint3>)second);
        }

        public static bool SequenceEqual(this List<uint3> first, ReadOnlySpan<uint3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (uint3* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<uint3> first, Memory<uint3> second)
        {
            return SequenceEqual((ReadOnlySpan<uint3>)first.Span, (ReadOnlySpan<uint3>)second.Span);
        }

        public static bool SequenceEqual(this Memory<uint3> first, ReadOnlyMemory<uint3> second)
        {
            return SequenceEqual((ReadOnlySpan<uint3>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<uint3> first, ReadOnlyMemory<uint3> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<uint3> first, Span<uint3> second)
        {
            return SequenceEqual((ReadOnlySpan<uint3>)first, (ReadOnlySpan<uint3>)second);
        }

        public static bool SequenceEqual(this Span<uint3> first, ReadOnlySpan<uint3> second)
        {
            return SequenceEqual((ReadOnlySpan<uint3>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<uint3> first, ReadOnlySpan<uint3> second)
        {
            if (first.Length != second.Length) return false;

            fixed (uint3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this uint4[] first, uint4[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (uint4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint4[] first, List<uint4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint4* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this uint4[] first, Memory<uint4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint4>)second.Span);
        }

        public static bool SequenceEqual(this uint4[] first, ReadOnlyMemory<uint4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this uint4[] first, Span<uint4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint4>)second);
        }

        public static bool SequenceEqual(this uint4[] first, ReadOnlySpan<uint4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (uint4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<uint4> first, uint4[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<uint4> first, List<uint4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (uint4* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<uint4> first, Memory<uint4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint4>)second.Span);
        }

        public static bool SequenceEqual(this List<uint4> first, ReadOnlyMemory<uint4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<uint4> first, Span<uint4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<uint4>)second);
        }

        public static bool SequenceEqual(this List<uint4> first, ReadOnlySpan<uint4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (uint4* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<uint4> first, Memory<uint4> second)
        {
            return SequenceEqual((ReadOnlySpan<uint4>)first.Span, (ReadOnlySpan<uint4>)second.Span);
        }

        public static bool SequenceEqual(this Memory<uint4> first, ReadOnlyMemory<uint4> second)
        {
            return SequenceEqual((ReadOnlySpan<uint4>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<uint4> first, ReadOnlyMemory<uint4> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<uint4> first, Span<uint4> second)
        {
            return SequenceEqual((ReadOnlySpan<uint4>)first, (ReadOnlySpan<uint4>)second);
        }

        public static bool SequenceEqual(this Span<uint4> first, ReadOnlySpan<uint4> second)
        {
            return SequenceEqual((ReadOnlySpan<uint4>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<uint4> first, ReadOnlySpan<uint4> second)
        {
            if (first.Length != second.Length) return false;

            fixed (uint4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this float2[] first, float2[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (float2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float2[] first, List<float2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float2* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float2[] first, Memory<float2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float2>)second.Span);
        }

        public static bool SequenceEqual(this float2[] first, ReadOnlyMemory<float2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this float2[] first, Span<float2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float2>)second);
        }

        public static bool SequenceEqual(this float2[] first, ReadOnlySpan<float2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (float2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<float2> first, float2[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<float2> first, List<float2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float2* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<float2> first, Memory<float2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float2>)second.Span);
        }

        public static bool SequenceEqual(this List<float2> first, ReadOnlyMemory<float2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<float2> first, Span<float2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float2>)second);
        }

        public static bool SequenceEqual(this List<float2> first, ReadOnlySpan<float2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (float2* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<float2> first, Memory<float2> second)
        {
            return SequenceEqual((ReadOnlySpan<float2>)first.Span, (ReadOnlySpan<float2>)second.Span);
        }

        public static bool SequenceEqual(this Memory<float2> first, ReadOnlyMemory<float2> second)
        {
            return SequenceEqual((ReadOnlySpan<float2>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<float2> first, ReadOnlyMemory<float2> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<float2> first, Span<float2> second)
        {
            return SequenceEqual((ReadOnlySpan<float2>)first, (ReadOnlySpan<float2>)second);
        }

        public static bool SequenceEqual(this Span<float2> first, ReadOnlySpan<float2> second)
        {
            return SequenceEqual((ReadOnlySpan<float2>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<float2> first, ReadOnlySpan<float2> second)
        {
            if (first.Length != second.Length) return false;

            fixed (float2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this float3[] first, float3[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (float3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float3[] first, List<float3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float3* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float3[] first, Memory<float3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float3>)second.Span);
        }

        public static bool SequenceEqual(this float3[] first, ReadOnlyMemory<float3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this float3[] first, Span<float3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float3>)second);
        }

        public static bool SequenceEqual(this float3[] first, ReadOnlySpan<float3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (float3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<float3> first, float3[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<float3> first, List<float3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float3* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<float3> first, Memory<float3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float3>)second.Span);
        }

        public static bool SequenceEqual(this List<float3> first, ReadOnlyMemory<float3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<float3> first, Span<float3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float3>)second);
        }

        public static bool SequenceEqual(this List<float3> first, ReadOnlySpan<float3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (float3* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<float3> first, Memory<float3> second)
        {
            return SequenceEqual((ReadOnlySpan<float3>)first.Span, (ReadOnlySpan<float3>)second.Span);
        }

        public static bool SequenceEqual(this Memory<float3> first, ReadOnlyMemory<float3> second)
        {
            return SequenceEqual((ReadOnlySpan<float3>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<float3> first, ReadOnlyMemory<float3> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<float3> first, Span<float3> second)
        {
            return SequenceEqual((ReadOnlySpan<float3>)first, (ReadOnlySpan<float3>)second);
        }

        public static bool SequenceEqual(this Span<float3> first, ReadOnlySpan<float3> second)
        {
            return SequenceEqual((ReadOnlySpan<float3>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<float3> first, ReadOnlySpan<float3> second)
        {
            if (first.Length != second.Length) return false;

            fixed (float3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this float4[] first, float4[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (float4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float4[] first, List<float4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float4* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this float4[] first, Memory<float4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float4>)second.Span);
        }

        public static bool SequenceEqual(this float4[] first, ReadOnlyMemory<float4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this float4[] first, Span<float4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float4>)second);
        }

        public static bool SequenceEqual(this float4[] first, ReadOnlySpan<float4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (float4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<float4> first, float4[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<float4> first, List<float4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (float4* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<float4> first, Memory<float4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float4>)second.Span);
        }

        public static bool SequenceEqual(this List<float4> first, ReadOnlyMemory<float4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<float4> first, Span<float4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<float4>)second);
        }

        public static bool SequenceEqual(this List<float4> first, ReadOnlySpan<float4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (float4* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<float4> first, Memory<float4> second)
        {
            return SequenceEqual((ReadOnlySpan<float4>)first.Span, (ReadOnlySpan<float4>)second.Span);
        }

        public static bool SequenceEqual(this Memory<float4> first, ReadOnlyMemory<float4> second)
        {
            return SequenceEqual((ReadOnlySpan<float4>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<float4> first, ReadOnlyMemory<float4> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<float4> first, Span<float4> second)
        {
            return SequenceEqual((ReadOnlySpan<float4>)first, (ReadOnlySpan<float4>)second);
        }

        public static bool SequenceEqual(this Span<float4> first, ReadOnlySpan<float4> second)
        {
            return SequenceEqual((ReadOnlySpan<float4>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<float4> first, ReadOnlySpan<float4> second)
        {
            if (first.Length != second.Length) return false;

            fixed (float4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this double2[] first, double2[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (double2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double2[] first, List<double2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double2* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double2[] first, Memory<double2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double2>)second.Span);
        }

        public static bool SequenceEqual(this double2[] first, ReadOnlyMemory<double2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this double2[] first, Span<double2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double2>)second);
        }

        public static bool SequenceEqual(this double2[] first, ReadOnlySpan<double2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (double2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<double2> first, double2[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<double2> first, List<double2> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double2* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<double2> first, Memory<double2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double2>)second.Span);
        }

        public static bool SequenceEqual(this List<double2> first, ReadOnlyMemory<double2> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<double2> first, Span<double2> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double2>)second);
        }

        public static bool SequenceEqual(this List<double2> first, ReadOnlySpan<double2> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (double2* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<double2> first, Memory<double2> second)
        {
            return SequenceEqual((ReadOnlySpan<double2>)first.Span, (ReadOnlySpan<double2>)second.Span);
        }

        public static bool SequenceEqual(this Memory<double2> first, ReadOnlyMemory<double2> second)
        {
            return SequenceEqual((ReadOnlySpan<double2>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<double2> first, ReadOnlyMemory<double2> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<double2> first, Span<double2> second)
        {
            return SequenceEqual((ReadOnlySpan<double2>)first, (ReadOnlySpan<double2>)second);
        }

        public static bool SequenceEqual(this Span<double2> first, ReadOnlySpan<double2> second)
        {
            return SequenceEqual((ReadOnlySpan<double2>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<double2> first, ReadOnlySpan<double2> second)
        {
            if (first.Length != second.Length) return false;

            fixed (double2* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this double3[] first, double3[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (double3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double3[] first, List<double3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double3* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double3[] first, Memory<double3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double3>)second.Span);
        }

        public static bool SequenceEqual(this double3[] first, ReadOnlyMemory<double3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this double3[] first, Span<double3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double3>)second);
        }

        public static bool SequenceEqual(this double3[] first, ReadOnlySpan<double3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (double3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<double3> first, double3[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<double3> first, List<double3> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double3* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<double3> first, Memory<double3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double3>)second.Span);
        }

        public static bool SequenceEqual(this List<double3> first, ReadOnlyMemory<double3> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<double3> first, Span<double3> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double3>)second);
        }

        public static bool SequenceEqual(this List<double3> first, ReadOnlySpan<double3> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (double3* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<double3> first, Memory<double3> second)
        {
            return SequenceEqual((ReadOnlySpan<double3>)first.Span, (ReadOnlySpan<double3>)second.Span);
        }

        public static bool SequenceEqual(this Memory<double3> first, ReadOnlyMemory<double3> second)
        {
            return SequenceEqual((ReadOnlySpan<double3>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<double3> first, ReadOnlyMemory<double3> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<double3> first, Span<double3> second)
        {
            return SequenceEqual((ReadOnlySpan<double3>)first, (ReadOnlySpan<double3>)second);
        }

        public static bool SequenceEqual(this Span<double3> first, ReadOnlySpan<double3> second)
        {
            return SequenceEqual((ReadOnlySpan<double3>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<double3> first, ReadOnlySpan<double3> second)
        {
            if (first.Length != second.Length) return false;

            fixed (double3* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
        public static bool SequenceEqual(this double4[] first, double4[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (double4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double4[] first, List<double4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double4* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this double4[] first, Memory<double4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double4>)second.Span);
        }

        public static bool SequenceEqual(this double4[] first, ReadOnlyMemory<double4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this double4[] first, Span<double4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double4>)second);
        }

        public static bool SequenceEqual(this double4[] first, ReadOnlySpan<double4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (double4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<double4> first, double4[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<double4> first, List<double4> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);

            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (double4* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<double4> first, Memory<double4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double4>)second.Span);
        }

        public static bool SequenceEqual(this List<double4> first, ReadOnlyMemory<double4> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<double4> first, Span<double4> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<double4>)second);
        }

        public static bool SequenceEqual(this List<double4> first, ReadOnlySpan<double4> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (double4* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<double4> first, Memory<double4> second)
        {
            return SequenceEqual((ReadOnlySpan<double4>)first.Span, (ReadOnlySpan<double4>)second.Span);
        }

        public static bool SequenceEqual(this Memory<double4> first, ReadOnlyMemory<double4> second)
        {
            return SequenceEqual((ReadOnlySpan<double4>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<double4> first, ReadOnlyMemory<double4> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<double4> first, Span<double4> second)
        {
            return SequenceEqual((ReadOnlySpan<double4>)first, (ReadOnlySpan<double4>)second);
        }

        public static bool SequenceEqual(this Span<double4> first, ReadOnlySpan<double4> second)
        {
            return SequenceEqual((ReadOnlySpan<double4>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<double4> first, ReadOnlySpan<double4> second)
        {
            if (first.Length != second.Length) return false;

            fixed (double4* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.SequenceEqual.cs.meta
================================================
fileFormatVersion: 2
guid: 688ab54d59cb2489b83bc2571ea87c9e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.SequenceEqual.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
#>
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static bool SequenceEqual(this <#=type#>[] first, <#=type#>[] second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);
            
            if (first == second) return true;
            if (first.Length != second.Length) return false;

            fixed (<#=type#>* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this <#=type#>[] first, List<<#=type#>> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);
            
            if (first.Length != second.Count) return false;

            var secondSpan = SpanHelper.AsSpan(second);
            fixed (<#=type#>* firstPtr = first, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this <#=type#>[] first, Memory<<#=type#>> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<<#=type#>>)second.Span);
        }

        public static bool SequenceEqual(this <#=type#>[] first, ReadOnlyMemory<<#=type#>> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this <#=type#>[] first, Span<<#=type#>> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<<#=type#>>)second);
        }

        public static bool SequenceEqual(this <#=type#>[] first, ReadOnlySpan<<#=type#>> second)
        {
            Error.ThrowIfNull(first);

            if (first.Length != second.Length) return false;

            fixed (<#=type#>* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }

        public static bool SequenceEqual(this List<<#=type#>> first, <#=type#>[] second)
        {
            return SequenceEqual(second, first);
        }

        public static bool SequenceEqual(this List<<#=type#>> first, List<<#=type#>> second)
        {
            Error.ThrowIfNull(first);
            Error.ThrowIfNull(second);
            
            if (first == second) return true;
            if (first.Count != second.Count) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            var secondSpan = SpanHelper.AsSpan(second);
            fixed (<#=type#>* firstPtr = firstSpan, secondPtr = secondSpan)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this List<<#=type#>> first, Memory<<#=type#>> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<<#=type#>>)second.Span);
        }

        public static bool SequenceEqual(this List<<#=type#>> first, ReadOnlyMemory<<#=type#>> second)
        {
            return SequenceEqual(first, second.Span);
        }

        public static bool SequenceEqual(this List<<#=type#>> first, Span<<#=type#>> second)
        {
            return SequenceEqual(first, (ReadOnlySpan<<#=type#>>)second);
        }

        public static bool SequenceEqual(this List<<#=type#>> first, ReadOnlySpan<<#=type#>> second)
        {
            Error.ThrowIfNull(first);

            if (first.Count != second.Length) return false;

            var firstSpan = SpanHelper.AsSpan(first);
            fixed (<#=type#>* firstPtr = firstSpan, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Count);
            }
        }

        public static bool SequenceEqual(this Memory<<#=type#>> first, Memory<<#=type#>> second)
        {
            return SequenceEqual((ReadOnlySpan<<#=type#>>)first.Span, (ReadOnlySpan<<#=type#>>)second.Span);
        }

        public static bool SequenceEqual(this Memory<<#=type#>> first, ReadOnlyMemory<<#=type#>> second)
        {
            return SequenceEqual((ReadOnlySpan<<#=type#>>)first.Span, second.Span);
        }

        public static bool SequenceEqual(this ReadOnlyMemory<<#=type#>> first, ReadOnlyMemory<<#=type#>> second)
        {
            return SequenceEqual(first.Span, second.Span);
        }

        public static bool SequenceEqual(this Span<<#=type#>> first, Span<<#=type#>> second)
        {
            return SequenceEqual((ReadOnlySpan<<#=type#>>)first, (ReadOnlySpan<<#=type#>>)second);
        }

        public static bool SequenceEqual(this Span<<#=type#>> first, ReadOnlySpan<<#=type#>> second)
        {
            return SequenceEqual((ReadOnlySpan<<#=type#>>)first, second);
        }

        public static bool SequenceEqual(this ReadOnlySpan<<#=type#>> first, ReadOnlySpan<<#=type#>> second)
        {
            if (first.Length != second.Length) return false;

            fixed (<#=type#>* firstPtr = first, secondPtr = second)
            {
                return SequenceEqualCore(firstPtr, secondPtr, first.Length);
            }
        }
<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.SequenceEqual.tt.meta
================================================
fileFormatVersion: 2
guid: 46ad07dd69d15432eadcd6ca697f2a5b
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Sum.cs
================================================
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
        public static int Sum(this int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (int* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static int Sum(this List<int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static int Sum(this Memory<int> source)
        {
            return Sum((ReadOnlySpan<int>)source.Span);
        }

        public static int Sum(this ReadOnlyMemory<int> source)
        {
            return Sum(source.Span);
        }

        public static int Sum(this Span<int> source)
        {
            return Sum((ReadOnlySpan<int>)source);
        }

        public static int Sum(this ReadOnlySpan<int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (int* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static uint Sum(this uint[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (uint* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static uint Sum(this List<uint> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static uint Sum(this Memory<uint> source)
        {
            return Sum((ReadOnlySpan<uint>)source.Span);
        }

        public static uint Sum(this ReadOnlyMemory<uint> source)
        {
            return Sum(source.Span);
        }

        public static uint Sum(this Span<uint> source)
        {
            return Sum((ReadOnlySpan<uint>)source);
        }

        public static uint Sum(this ReadOnlySpan<uint> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (uint* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static long Sum(this long[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (long* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static long Sum(this List<long> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (long* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static long Sum(this Memory<long> source)
        {
            return Sum((ReadOnlySpan<long>)source.Span);
        }

        public static long Sum(this ReadOnlyMemory<long> source)
        {
            return Sum(source.Span);
        }

        public static long Sum(this Span<long> source)
        {
            return Sum((ReadOnlySpan<long>)source);
        }

        public static long Sum(this ReadOnlySpan<long> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (long* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static ulong Sum(this ulong[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (ulong* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static ulong Sum(this List<ulong> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (ulong* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static ulong Sum(this Memory<ulong> source)
        {
            return Sum((ReadOnlySpan<ulong>)source.Span);
        }

        public static ulong Sum(this ReadOnlyMemory<ulong> source)
        {
            return Sum(source.Span);
        }

        public static ulong Sum(this Span<ulong> source)
        {
            return Sum((ReadOnlySpan<ulong>)source);
        }

        public static ulong Sum(this ReadOnlySpan<ulong> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (ulong* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float Sum(this float[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (float* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float Sum(this List<float> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float Sum(this Memory<float> source)
        {
            return Sum((ReadOnlySpan<float>)source.Span);
        }

        public static float Sum(this ReadOnlyMemory<float> source)
        {
            return Sum(source.Span);
        }

        public static float Sum(this Span<float> source)
        {
            return Sum((ReadOnlySpan<float>)source);
        }

        public static float Sum(this ReadOnlySpan<float> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (float* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double Sum(this double[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (double* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double Sum(this List<double> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double Sum(this Memory<double> source)
        {
            return Sum((ReadOnlySpan<double>)source.Span);
        }

        public static double Sum(this ReadOnlyMemory<double> source)
        {
            return Sum(source.Span);
        }

        public static double Sum(this Span<double> source)
        {
            return Sum((ReadOnlySpan<double>)source);
        }

        public static double Sum(this ReadOnlySpan<double> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (double* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector2 Sum(this Vector2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (Vector2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector2 Sum(this List<Vector2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector2* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector2 Sum(this Memory<Vector2> source)
        {
            return Sum((ReadOnlySpan<Vector2>)source.Span);
        }

        public static Vector2 Sum(this ReadOnlyMemory<Vector2> source)
        {
            return Sum(source.Span);
        }

        public static Vector2 Sum(this Span<Vector2> source)
        {
            return Sum((ReadOnlySpan<Vector2>)source);
        }

        public static Vector2 Sum(this ReadOnlySpan<Vector2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (Vector2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector2Int Sum(this Vector2Int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (Vector2Int* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector2Int Sum(this List<Vector2Int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector2Int* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector2Int Sum(this Memory<Vector2Int> source)
        {
            return Sum((ReadOnlySpan<Vector2Int>)source.Span);
        }

        public static Vector2Int Sum(this ReadOnlyMemory<Vector2Int> source)
        {
            return Sum(source.Span);
        }

        public static Vector2Int Sum(this Span<Vector2Int> source)
        {
            return Sum((ReadOnlySpan<Vector2Int>)source);
        }

        public static Vector2Int Sum(this ReadOnlySpan<Vector2Int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (Vector2Int* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector3 Sum(this Vector3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (Vector3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector3 Sum(this List<Vector3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector3* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector3 Sum(this Memory<Vector3> source)
        {
            return Sum((ReadOnlySpan<Vector3>)source.Span);
        }

        public static Vector3 Sum(this ReadOnlyMemory<Vector3> source)
        {
            return Sum(source.Span);
        }

        public static Vector3 Sum(this Span<Vector3> source)
        {
            return Sum((ReadOnlySpan<Vector3>)source);
        }

        public static Vector3 Sum(this ReadOnlySpan<Vector3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (Vector3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector3Int Sum(this Vector3Int[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (Vector3Int* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector3Int Sum(this List<Vector3Int> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector3Int* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector3Int Sum(this Memory<Vector3Int> source)
        {
            return Sum((ReadOnlySpan<Vector3Int>)source.Span);
        }

        public static Vector3Int Sum(this ReadOnlyMemory<Vector3Int> source)
        {
            return Sum(source.Span);
        }

        public static Vector3Int Sum(this Span<Vector3Int> source)
        {
            return Sum((ReadOnlySpan<Vector3Int>)source);
        }

        public static Vector3Int Sum(this ReadOnlySpan<Vector3Int> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (Vector3Int* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static Vector4 Sum(this Vector4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (Vector4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static Vector4 Sum(this List<Vector4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (Vector4* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static Vector4 Sum(this Memory<Vector4> source)
        {
            return Sum((ReadOnlySpan<Vector4>)source.Span);
        }

        public static Vector4 Sum(this ReadOnlyMemory<Vector4> source)
        {
            return Sum(source.Span);
        }

        public static Vector4 Sum(this Span<Vector4> source)
        {
            return Sum((ReadOnlySpan<Vector4>)source);
        }

        public static Vector4 Sum(this ReadOnlySpan<Vector4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (Vector4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static int2 Sum(this int2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (int2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static int2 Sum(this List<int2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int2* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static int2 Sum(this Memory<int2> source)
        {
            return Sum((ReadOnlySpan<int2>)source.Span);
        }

        public static int2 Sum(this ReadOnlyMemory<int2> source)
        {
            return Sum(source.Span);
        }

        public static int2 Sum(this Span<int2> source)
        {
            return Sum((ReadOnlySpan<int2>)source);
        }

        public static int2 Sum(this ReadOnlySpan<int2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (int2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static int3 Sum(this int3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (int3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static int3 Sum(this List<int3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int3* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static int3 Sum(this Memory<int3> source)
        {
            return Sum((ReadOnlySpan<int3>)source.Span);
        }

        public static int3 Sum(this ReadOnlyMemory<int3> source)
        {
            return Sum(source.Span);
        }

        public static int3 Sum(this Span<int3> source)
        {
            return Sum((ReadOnlySpan<int3>)source);
        }

        public static int3 Sum(this ReadOnlySpan<int3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (int3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static int4 Sum(this int4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (int4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static int4 Sum(this List<int4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (int4* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static int4 Sum(this Memory<int4> source)
        {
            return Sum((ReadOnlySpan<int4>)source.Span);
        }

        public static int4 Sum(this ReadOnlyMemory<int4> source)
        {
            return Sum(source.Span);
        }

        public static int4 Sum(this Span<int4> source)
        {
            return Sum((ReadOnlySpan<int4>)source);
        }

        public static int4 Sum(this ReadOnlySpan<int4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (int4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static uint2 Sum(this uint2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (uint2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static uint2 Sum(this List<uint2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint2* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static uint2 Sum(this Memory<uint2> source)
        {
            return Sum((ReadOnlySpan<uint2>)source.Span);
        }

        public static uint2 Sum(this ReadOnlyMemory<uint2> source)
        {
            return Sum(source.Span);
        }

        public static uint2 Sum(this Span<uint2> source)
        {
            return Sum((ReadOnlySpan<uint2>)source);
        }

        public static uint2 Sum(this ReadOnlySpan<uint2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (uint2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static uint3 Sum(this uint3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (uint3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static uint3 Sum(this List<uint3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint3* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static uint3 Sum(this Memory<uint3> source)
        {
            return Sum((ReadOnlySpan<uint3>)source.Span);
        }

        public static uint3 Sum(this ReadOnlyMemory<uint3> source)
        {
            return Sum(source.Span);
        }

        public static uint3 Sum(this Span<uint3> source)
        {
            return Sum((ReadOnlySpan<uint3>)source);
        }

        public static uint3 Sum(this ReadOnlySpan<uint3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (uint3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static uint4 Sum(this uint4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (uint4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static uint4 Sum(this List<uint4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (uint4* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static uint4 Sum(this Memory<uint4> source)
        {
            return Sum((ReadOnlySpan<uint4>)source.Span);
        }

        public static uint4 Sum(this ReadOnlyMemory<uint4> source)
        {
            return Sum(source.Span);
        }

        public static uint4 Sum(this Span<uint4> source)
        {
            return Sum((ReadOnlySpan<uint4>)source);
        }

        public static uint4 Sum(this ReadOnlySpan<uint4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (uint4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float2 Sum(this float2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (float2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float2 Sum(this List<float2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float2* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float2 Sum(this Memory<float2> source)
        {
            return Sum((ReadOnlySpan<float2>)source.Span);
        }

        public static float2 Sum(this ReadOnlyMemory<float2> source)
        {
            return Sum(source.Span);
        }

        public static float2 Sum(this Span<float2> source)
        {
            return Sum((ReadOnlySpan<float2>)source);
        }

        public static float2 Sum(this ReadOnlySpan<float2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (float2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float3 Sum(this float3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (float3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float3 Sum(this List<float3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float3* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float3 Sum(this Memory<float3> source)
        {
            return Sum((ReadOnlySpan<float3>)source.Span);
        }

        public static float3 Sum(this ReadOnlyMemory<float3> source)
        {
            return Sum(source.Span);
        }

        public static float3 Sum(this Span<float3> source)
        {
            return Sum((ReadOnlySpan<float3>)source);
        }

        public static float3 Sum(this ReadOnlySpan<float3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (float3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static float4 Sum(this float4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (float4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static float4 Sum(this List<float4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (float4* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static float4 Sum(this Memory<float4> source)
        {
            return Sum((ReadOnlySpan<float4>)source.Span);
        }

        public static float4 Sum(this ReadOnlyMemory<float4> source)
        {
            return Sum(source.Span);
        }

        public static float4 Sum(this Span<float4> source)
        {
            return Sum((ReadOnlySpan<float4>)source);
        }

        public static float4 Sum(this ReadOnlySpan<float4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (float4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double2 Sum(this double2[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (double2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double2 Sum(this List<double2> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double2* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double2 Sum(this Memory<double2> source)
        {
            return Sum((ReadOnlySpan<double2>)source.Span);
        }

        public static double2 Sum(this ReadOnlyMemory<double2> source)
        {
            return Sum(source.Span);
        }

        public static double2 Sum(this Span<double2> source)
        {
            return Sum((ReadOnlySpan<double2>)source);
        }

        public static double2 Sum(this ReadOnlySpan<double2> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (double2* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double3 Sum(this double3[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (double3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double3 Sum(this List<double3> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double3* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double3 Sum(this Memory<double3> source)
        {
            return Sum((ReadOnlySpan<double3>)source.Span);
        }

        public static double3 Sum(this ReadOnlyMemory<double3> source)
        {
            return Sum(source.Span);
        }

        public static double3 Sum(this Span<double3> source)
        {
            return Sum((ReadOnlySpan<double3>)source);
        }

        public static double3 Sum(this ReadOnlySpan<double3> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (double3* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
        public static double4 Sum(this double4[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (double4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static double4 Sum(this List<double4> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (double4* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static double4 Sum(this Memory<double4> source)
        {
            return Sum((ReadOnlySpan<double4>)source.Span);
        }

        public static double4 Sum(this ReadOnlyMemory<double4> source)
        {
            return Sum(source.Span);
        }

        public static double4 Sum(this Span<double4> source)
        {
            return Sum((ReadOnlySpan<double4>)source);
        }

        public static double4 Sum(this ReadOnlySpan<double4> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (double4* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Sum.cs.meta
================================================
fileFormatVersion: 2
guid: 0f6fa0c26972249c2a78d5cc0d4336fe
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Sum.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    var types = new string[]
    {
        "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
#>
using System;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

namespace BurstLinq
{
    public unsafe static partial class BurstLinqExtensions
    {
<# foreach(var type in types) { #>
        public static <#=type#> Sum(this <#=type#>[] source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Length);
            fixed (<#=type#>* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }

        public static <#=type#> Sum(this List<<#=type#>> source)
        {
            Error.ThrowIfNull(source);
            Error.ThrowIfEmpty(source.Count);

            var span = SpanHelper.AsSpan(source);
            fixed (<#=type#>* ptr = span)
            {
                SumCore(ptr, source.Count, out var result);
                return result;
            }
        }

        public static <#=type#> Sum(this Memory<<#=type#>> source)
        {
            return Sum((ReadOnlySpan<<#=type#>>)source.Span);
        }

        public static <#=type#> Sum(this ReadOnlyMemory<<#=type#>> source)
        {
            return Sum(source.Span);
        }

        public static <#=type#> Sum(this Span<<#=type#>> source)
        {
            return Sum((ReadOnlySpan<<#=type#>>)source);
        }

        public static <#=type#> Sum(this ReadOnlySpan<<#=type#>> source)
        {
            Error.ThrowIfEmpty(source.IsEmpty);
            fixed (<#=type#>* ptr = source)
            {
                SumCore(ptr, source.Length, out var result);
                return result;
            }
        }
<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.Sum.tt.meta
================================================
fileFormatVersion: 2
guid: 740008369ba8d4a3381adaa087070605
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.cs
================================================
using Unity.Burst;

namespace BurstLinq
{
    [BurstCompile(OptimizeFor = OptimizeFor.Performance)]
    public static partial class BurstLinqExtensions
    {

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/BurstLinqExtensions.cs.meta
================================================
fileFormatVersion: 2
guid: 66be7336c90984baaab6a9756a847e1a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/CmpHelpers.cs
================================================
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;

namespace BurstLinq
{
    [BurstCompile]
    internal static unsafe class CmpHelpers
    {
        [BurstCompile]
        public static bool MemCmp(void* ptr1, void* ptr2, long size)
        {
            return UnsafeUtility.MemCmp(ptr1, ptr2, size) == 0;
        }

        [BurstCompile]
        public static bool FloatCmp(float* ptr1, float* ptr2, [AssumeRange(1, long.MaxValue)] long length)
        {
            long index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                static bool8 _equals256(v256 a, v256 b)
                {
                    return new bool8(
                        a.Float0 == b.Float0,
                        a.Float1 == b.Float1,
                        a.Float2 == b.Float2,
                        a.Float3 == b.Float3,
                        a.Float4 == b.Float4,
                        a.Float5 == b.Float5,
                        a.Float6 == b.Float6,
                        a.Float7 == b.Float7
                    );
                }

                var packingLength = sizeof(v256) / sizeof(float);

                for (; index < length - packingLength; index += packingLength)
                {
                    if (!_equals256(*(v256*)(ptr1 + index), *(v256*)(ptr2 + index)).all())
                        return false;
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                var packingLength = sizeof(v128) / sizeof(float);

                for (; index < length - packingLength; index += packingLength)
                {
                    if (math.any(*(float4*)(ptr1 + index) != *(float4*)(ptr2 + index))) return false;
                }
            }

            for (; index < length; index++)
            {
                if (ptr1[index] != ptr2[index]) return false;
            }

            return true;
        }

        [BurstCompile]
        public static bool DoubleCmp(double* ptr1, double* ptr2, [AssumeRange(1, long.MaxValue)] long length)
        {
            long index = 0;
            if (BurstHelpers.IsV256Supported)
            {
                var packingLength = sizeof(v256) / sizeof(double);

                for (; index < length - packingLength; index += packingLength)
                {
                    if (math.any(*(double4*)(ptr1 + index) != *(double4*)(ptr2 + index))) return false;
                }
            }
            else if (BurstHelpers.IsV128Supported)
            {
                var packingLength = sizeof(v128) / sizeof(double);

                for (; index < length - packingLength; index += packingLength)
                {
                    if (math.any(*(double2*)(ptr1 + index) != *(double2*)(ptr2 + index))) return false;
                }
            }

            for (; index < length; index++)
            {
                if (ptr1[index] != ptr2[index]) return false;
            }
            return true;
        }

    }
}

================================================
FILE: Assets/BurstLinq/Runtime/CmpHelpers.cs.meta
================================================
fileFormatVersion: 2
guid: e727f3cb65621412f8927f011e760a82
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/Error.cs
================================================
using System;
using System.Runtime.CompilerServices;

namespace BurstLinq
{
    internal static class Error
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void ThrowIfNull<T>(T obj)
        {
            if (obj == null) throw new ArgumentNullException();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void ThrowIfEmpty(int length)
        {
            if (length <= 0) throw new InvalidOperationException("Sequence contains no elements");
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void ThrowIfEmpty(bool isEmpty)
        {
            if (isEmpty) throw new InvalidOperationException("Sequence contains no elements");
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/Error.cs.meta
================================================
fileFormatVersion: 2
guid: 947a1f13c914d44aebc6da923dd1c657
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/SpanHelper.cs
================================================
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Unity.Burst;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;

namespace BurstLinq
{
    // Class for extracting the contents of List with UnsafeUtility.As
    internal sealed class ListView<T>
    {
        public T[] _items;
    }

    [BurstCompile]
    internal static class SpanHelper
    {
        [BurstCompile]
        public static unsafe void CopyFrom<T>(in NativeArray<T> array, in ReadOnlySpan<T> source)
            where T : unmanaged
        {
            CheckLength(source.Length, array.Length);
            void* dstPtr = array.GetUnsafePtr();

            fixed (void* srcPtr = source)
            {
                UnsafeUtility.MemCpy(dstPtr, srcPtr, array.Length * UnsafeUtility.SizeOf<T>());
            }
        }

        public static Span<T> AsSpan<T>(List<T> list) where T : unmanaged
        {
            ref var view = ref UnsafeUtility.As<List<T>, ListView<T>>(ref list);
            return view._items.AsSpan(0, list.Count);
        }

        [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
        static void CheckLength(int srcLength, int dstLength)
        {
            if (srcLength != dstLength) throw new ArgumentException("source and destination length must be the same");
        }
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/SpanHelper.cs.meta
================================================
fileFormatVersion: 2
guid: 7723c8bdc26dc44c3934d82af7ee3843
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime/Vectors.cs
================================================
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Unity.Mathematics;

namespace BurstLinq
{
    internal static class VectorExtensions
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool any(this bool2 v) => v.x || v.y;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool any(this bool3 v) => v.x || v.y || v.z;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool any(this bool4 v) => v.x || v.y || v.z || v.w;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool all(this bool2 v) => v.x && v.y;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool all(this bool3 v) => v.x && v.y && v.z;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool all(this bool4 v) => v.x && v.y && v.z && v.w;
    }

    [Serializable]
    [StructLayout(LayoutKind.Explicit, Size = 32 * sizeof(bool))]
    internal struct bool32
    {
        [FieldOffset(0)]
        public bool x0;

        [FieldOffset(1)]
        public bool x1;

        [FieldOffset(2)]
        public bool x2;

        [FieldOffset(3)]
        public bool x3;

        [FieldOffset(4)]
        public bool x4;

        [FieldOffset(5)]
        public bool x5;

        [FieldOffset(6)]
        public bool x6;

        [FieldOffset(7)]
        public bool x7;

        [FieldOffset(8)]
        public bool x8;

        [FieldOffset(9)]
        public bool x9;

        [FieldOffset(10)]
        public bool x10;

        [FieldOffset(11)]
        public bool x11;

        [FieldOffset(12)]
        public bool x12;

        [FieldOffset(13)]
        public bool x13;

        [FieldOffset(14)]
        public bool x14;

        [FieldOffset(15)]
        public bool x15;

        [FieldOffset(16)]
        public bool x16;

        [FieldOffset(17)]
        public bool x17;

        [FieldOffset(18)]
        public bool x18;

        [FieldOffset(19)]
        public bool x19;

        [FieldOffset(20)]
        public bool x20;

        [FieldOffset(21)]
        public bool x21;

        [FieldOffset(22)]
        public bool x22;

        [FieldOffset(23)]
        public bool x23;

        [FieldOffset(24)]
        public bool x24;

        [FieldOffset(25)]
        public bool x25;

        [FieldOffset(26)]
        public bool x26;

        [FieldOffset(27)]
        public bool x27;

        [FieldOffset(28)]
        public bool x28;

        [FieldOffset(29)]
        public bool x29;

        [FieldOffset(30)]
        public bool x30;

        [FieldOffset(31)]
        public bool x31;

        public bool32(bool x0, bool x1, bool x2, bool x3, bool x4, bool x5, bool x6, bool x7, bool x8, bool x9, bool x10, bool x11, bool x12, bool x13, bool x14, bool x15, bool x16, bool x17, bool x18, bool x19, bool x20, bool x21, bool x22, bool x23, bool x24, bool x25, bool x26, bool x27, bool x28, bool x29, bool x30, bool x31)
        {
            this.x0 = x0;
            this.x1 = x1;
            this.x2 = x2;
            this.x3 = x3;
            this.x4 = x4;
            this.x5 = x5;
            this.x6 = x6;
            this.x7 = x7;
            this.x8 = x8;
            this.x9 = x9;
            this.x10 = x10;
            this.x11 = x11;
            this.x12 = x12;
            this.x13 = x13;
            this.x14 = x14;
            this.x15 = x15;
            this.x16 = x16;
            this.x17 = x17;
            this.x18 = x18;
            this.x19 = x19;
            this.x20 = x20;
            this.x21 = x21;
            this.x22 = x22;
            this.x23 = x23;
            this.x24 = x24;
            this.x25 = x25;
            this.x26 = x26;
            this.x27 = x27;
            this.x28 = x28;
            this.x29 = x29;
            this.x30 = x30;
            this.x31 = x31;
        }

        public bool any() => x0 || x1 || x2 || x3 || x4 || x5 || x6 || x7 || x8 || x9 || x10 || x11 || x12 || x13 || x14 || x15 || x16 || x17 || x18 || x19 || x20 || x21 || x22 || x23 || x24 || x25 || x26 || x27 || x28 || x29 || x30 || x31;
        public bool all() => x0 && x1 && x2 && x3 && x4 && x5 && x6 && x7 && x8 && x9 && x10 && x11 && x12 && x13 && x14 && x15 && x16 && x17 && x18 && x19 && x20 && x21 && x22 && x23 && x24 && x25 && x26 && x27 && x28 && x29 && x30 && x31;
    }

    [Serializable]
    [StructLayout(LayoutKind.Explicit, Size = 16 * sizeof(bool))]
    internal struct bool16
    {
        [FieldOffset(0)]
        public bool x0;

        [FieldOffset(1)]
        public bool x1;

        [FieldOffset(2)]
        public bool x2;

        [FieldOffset(3)]
        public bool x3;

        [FieldOffset(4)]
        public bool x4;

        [FieldOffset(5)]
        public bool x5;

        [FieldOffset(6)]
        public bool x6;

        [FieldOffset(7)]
        public bool x7;

        [FieldOffset(8)]
        public bool x8;

        [FieldOffset(9)]
        public bool x9;

        [FieldOffset(10)]

        public bool x10;

        [FieldOffset(11)]

        public bool x11;

        [FieldOffset(12)]

        public bool x12;

        [FieldOffset(13)]

        public bool x13;

        [FieldOffset(14)]

        public bool x14;

        [FieldOffset(15)]

        public bool x15;

        public bool16(bool x0, bool x1, bool x2, bool x3, bool x4, bool x5, bool x6, bool x7, bool x8, bool x9, bool x10, bool x11, bool x12, bool x13, bool x14, bool x15)
        {
            this.x0 = x0;
            this.x1 = x1;
            this.x2 = x2;
            this.x3 = x3;
            this.x4 = x4;
            this.x5 = x5;
            this.x6 = x6;
            this.x7 = x7;
            this.x8 = x8;
            this.x9 = x9;
            this.x10 = x10;
            this.x11 = x11;
            this.x12 = x12;
            this.x13 = x13;
            this.x14 = x14;
            this.x15 = x15;
        }


        public bool any() => x0 || x1 || x2 || x3 || x4 || x5 || x6 || x7 || x8 || x9 || x10 || x11 || x12 || x13 || x14 || x15;
        public bool all() => x0 && x1 && x2 && x3 && x4 && x5 && x6 && x7 || x8 && x9 && x10 && x11 && x12 && x13 && x14 && x15;
    }

    [Serializable]
    [StructLayout(LayoutKind.Explicit, Size = 8 * sizeof(bool))]
    internal struct bool8
    {
        [FieldOffset(0)]
        public bool x0;

        [FieldOffset(1)]
        public bool x1;

        [FieldOffset(2)]
        public bool x2;

        [FieldOffset(3)]
        public bool x3;

        [FieldOffset(4)]
        public bool x4;

        [FieldOffset(5)]
        public bool x5;

        [FieldOffset(6)]
        public bool x6;

        [FieldOffset(7)]
        public bool x7;
        public bool8(bool x0, bool x1, bool x2, bool x3, bool x4, bool x5, bool x6, bool x7)
        {
            this.x0 = x0;
            this.x1 = x1;
            this.x2 = x2;
            this.x3 = x3;
            this.x4 = x4;
            this.x5 = x5;
            this.x6 = x6;
            this.x7 = x7;
        }

        public bool any() => x0 || x1 || x2 || x3 || x4 || x5 || x6 || x7;
        public bool all() => x0 && x1 && x2 && x3 && x4 && x5 && x6 && x7;
    }
}

================================================
FILE: Assets/BurstLinq/Runtime/Vectors.cs.meta
================================================
fileFormatVersion: 2
guid: 1f2d942b28d6b4a7c9962b2614ef9190
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Runtime.meta
================================================
fileFormatVersion: 2
guid: bcb9141eec5a6493d8e1f71aea2aac29
folderAsset: yes
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/AssertEx.cs
================================================
using System;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Assertions;

namespace BurstLinq.Tests
{
    public static class AssertEx
    {
        public static void AreApproximatelyEqual(float a, float b)
        {
            Assert.AreApproximatelyEqual(a, b, 0.1f);
        }

        public static void AreApproximatelyEqual(Vector2 a, Vector2 b)
        {
            Assert.AreApproximatelyEqual(a.x, b.x, 0.1f);
            Assert.AreApproximatelyEqual(a.y, b.y, 0.1f);
        }

        public static void AreApproximatelyEqual(Vector3 a, Vector3 b)
        {
            Assert.AreApproximatelyEqual(a.x, b.x, 0.1f);
            Assert.AreApproximatelyEqual(a.y, b.y, 0.1f);
            Assert.AreApproximatelyEqual(a.z, b.z, 0.1f);
        }

        public static void AreApproximatelyEqual(Vector4 a, Vector4 b)
        {
            Assert.AreApproximatelyEqual(a.x, b.x, 0.1f);
            Assert.AreApproximatelyEqual(a.y, b.y, 0.1f);
            Assert.AreApproximatelyEqual(a.z, b.z, 0.1f);
            Assert.AreApproximatelyEqual(a.w, b.w, 0.1f);
        }

        public static void AreApproximatelyEqual(double a, double b)
        {
            Assert.IsTrue(Math.Abs(a - b) < 0.001);
        }

        public static void AreApproximatelyEqual(double2 a, double2 b)
        {
            AreApproximatelyEqual(a.x, b.x);
            AreApproximatelyEqual(a.y, b.y);
        }

        public static void AreApproximatelyEqual(double3 a, double3 b)
        {
            AreApproximatelyEqual(a.x, b.x);
            AreApproximatelyEqual(a.y, b.y);
            AreApproximatelyEqual(a.z, b.z);
        }

        public static void AreApproximatelyEqual(double4 a, double4 b)
        {
            AreApproximatelyEqual(a.x, b.x);
            AreApproximatelyEqual(a.y, b.y);
            AreApproximatelyEqual(a.z, b.z);
            AreApproximatelyEqual(a.w, b.w);
        }

        public static void AreApproximatelyEqual(float2 a, float2 b)
        {
            Assert.AreApproximatelyEqual(a.x, b.x, 0.1f);
            Assert.AreApproximatelyEqual(a.y, b.y, 0.1f);
        }

        public static void AreApproximatelyEqual(float3 a, float3 b)
        {
            Assert.AreApproximatelyEqual(a.x, b.x, 0.1f);
            Assert.AreApproximatelyEqual(a.y, b.y, 0.1f);
            Assert.AreApproximatelyEqual(a.z, b.z, 0.1f);
        }

        public static void AreApproximatelyEqual(float4 a, float4 b)
        {
            Assert.AreApproximatelyEqual(a.x, b.x, 0.1f);
            Assert.AreApproximatelyEqual(a.y, b.y, 0.1f);
            Assert.AreApproximatelyEqual(a.z, b.z, 0.1f);
            Assert.AreApproximatelyEqual(a.w, b.w, 0.1f);
        }
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/AssertEx.cs.meta
================================================
fileFormatVersion: 2
guid: 4e5dd188b1cd44c4ead7c1aa8da6ae4d
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/AverageTest.cs
================================================
using System;
using System.Linq;
using NUnit.Framework;
using UnityEngine;
using Unity.Mathematics;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class AverageTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 100; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Average(list);
                var result2 = BurstLinqExtensions.Average(list);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt(0, 100, 1000).ToArray();

                var result1 = Enumerable.Average(array);
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt(0, 100, 1000).ToArray();

                uint sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Long()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatLong(0, 100, 1000).ToArray();

                var result1 = Enumerable.Average(array);
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_ULong()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatULong(0, 100, 1000).ToArray();

                ulong sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat(0, 100, 1000).ToArray();

                var result1 = Enumerable.Average(array);
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble(0, 100, 1000).ToArray();

                var result1 = Enumerable.Average(array);
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector2(0, 100, 1000).ToArray();

                Vector2 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (Vector2)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector2Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector2Int(0, 100, 1000).ToArray();

                Vector2Int sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (Vector2)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector3(0, 100, 1000).ToArray();

                Vector3 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (Vector3)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector3Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector3Int(0, 100, 1000).ToArray();

                Vector3Int sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (Vector3)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector4(0, 100, 1000).ToArray();

                Vector4 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (Vector4)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt2(0, 100, 1000).ToArray();

                int2 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double2)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt3(0, 100, 1000).ToArray();

                int3 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double3)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt4(0, 100, 1000).ToArray();

                int4 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double4)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat2(0, 100, 1000).ToArray();

                float2 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (float2)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat3(0, 100, 1000).ToArray();

                float3 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (float3)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat4(0, 100, 1000).ToArray();

                float4 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (float4)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble2(0, 100, 1000).ToArray();

                double2 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double2)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble3(0, 100, 1000).ToArray();

                double3 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double3)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble4(0, 100, 1000).ToArray();

                double4 sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (double4)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/AverageTest.cs.meta
================================================
fileFormatVersion: 2
guid: 28462f0a22ab54b8eb216473e8105c23
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/AverageTest.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    string GetTypeName(string typeName)
    {
        if (typeName[0] == 'u') return "U" + char.ToUpper(typeName[1]) + typeName.Substring(2);
        if (typeName == "sbyte") return "SByte";
        return char.ToUpper(typeName[0]) + typeName.Substring(1);
    }

    bool IsLinqSupport(string typeName)
    {
        return typeName is "int" or "long" or "float" or "double";
    }

    bool IsFloat(string typeName)
    {
        return typeName is "float" or "float2" or "float3" or "float4"
            or "double" or "double2" or "double3" or "double4"
            or "Vector2" or "Vector3" or "Vector4";
    }

    var types = new string[]
    {
        "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };

    System.Func<string, string> retType = (string x) => 
    {
        switch (x)
        {
            default: return "double";
            case "float": return "float";
            case "Vector2":
            case "Vector2Int": return "Vector2";
            case "Vector3":
            case "Vector3Int": return "Vector3";
            case "Vector4": return "Vector4";
            case "float2": return "float2";
            case "float3": return "float3";
            case "float4": return "float4";
            case "int2":
            case "double2": return "double2";
            case "int3":
            case "double3": return "double3";
            case "int4":
            case "double4": return "double4";
        }
        return "";
    };
#>
using System;
using System.Linq;
using NUnit.Framework;
using UnityEngine;
using Unity.Mathematics;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class AverageTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 100; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Average(list);
                var result2 = BurstLinqExtensions.Average(list);

                Assert.AreEqual(result1, result2);
            }
        }

<# foreach(var type in types) { #>
        [Test]
        public void Test_Array_<#=GetTypeName(type)#>()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.Repeat<#=GetTypeName(type)#>(0, 100, 1000).ToArray();

<# if (IsLinqSupport(type)) { #>
                var result1 = Enumerable.Average(array);
                var result2 = BurstLinqExtensions.Average(array);
<# } else { #>
                <#=type#> sum = default;
                for (int n = 0; n < array.Length; n++) sum += array[n];
                var result1 = (<#=retType(type)#>)sum / array.Length;
                var result2 = BurstLinqExtensions.Average(array);
<# } #>

<# if (IsFloat(retType(type))) { #>
                AssertEx.AreApproximatelyEqual(result1, result2);
<# } else { #>
                Assert.AreEqual(result1, result2);
<# } #>
            }
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/AverageTest.tt.meta
================================================
fileFormatVersion: 2
guid: f7d1190a97bce4842b286021d8796d4d
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/Benchmark.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Unity.PerformanceTesting;

#pragma warning disable CS0219

namespace BurstLinq.Tests
{
    public class BenchmarkFloatSum
    {
        const int WarmupCount = 5;
        const int MeasurementCount = 100;

        static readonly float[] array = Enumerable.Repeat(1.0f, 10000).ToArray();

        [TearDown]
        public void TearDown()
        {
            GC.Collect();
        }

        [Test, Performance]
        public void For()
        {
            Measure.Method(() =>
            {
                if (array == null) return;

                var result = 0.0f;
                for (int i = 0; i < array.Length; i++)
                {
                    result += array[i];
                }
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Float Sum: For", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void LINQ()
        {
            Measure.Method(() =>
            {
                Enumerable.Sum(array);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Float Sum: LINQ", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void BurstLinq()
        {
            Measure.Method(() =>
            {
                BurstLinqExtensions.Sum(array);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Float Sum: BurstLinq", SampleUnit.Microsecond))
            .Run();
        }
    }

    public class BenchmarkIntSequenceEqual
    {
        const int WarmupCount = 5;
        const int MeasurementCount = 100;

        static readonly int[] array1 = Enumerable.Range(0, 10000).ToArray();
        static readonly int[] array2 = Enumerable.Range(0, 10000).ToArray();

        [TearDown]
        public void TearDown()
        {
            GC.Collect();
        }

        [Test, Performance]
        public void For()
        {
            Measure.Method(() =>
            {
                if (array1 == null) return;
                if (array2 == null) return;

                var result = true;
                if (array1.Length != array2.Length)
                {
                    result = false;
                    return;
                }

                for (int i = 0; i < array1.Length; i++)
                {
                    if (array1[i] != array2[i])
                    {
                        result = false;
                        break;
                    }
                }
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int SequenceEqual: For", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void LINQ()
        {
            Measure.Method(() =>
            {
                Enumerable.SequenceEqual(array1, array2);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int SequenceEqual: LINQ", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void BurstLinq()
        {
            Measure.Method(() =>
            {
                BurstLinqExtensions.SequenceEqual(array1, array2);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int SequenceEqual: BurstLinq", SampleUnit.Microsecond))
            .Run();
        }
    }

    public class BenchmarkDoubleMin
    {
        const int WarmupCount = 5;
        const int MeasurementCount = 100;

        static readonly double[] array = DoubleRange(10000).ToArray();
        static IEnumerable<double> DoubleRange(int count)
        {
            var current = 0.0;
            for (int i = 0; i < count; i++) yield return current++;
        }

        [TearDown]
        public void TearDown()
        {
            GC.Collect();
        }

        [Test, Performance]
        public void For()
        {
            Measure.Method(() =>
            {
                if (array == null) return;

                var result = double.MaxValue;
                for (int i = 0; i < array.Length; i++)
                {
                    if (array[i] < result) result = array[i];
                }
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Double Min: For", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void LINQ()
        {
            Measure.Method(() =>
            {
                Enumerable.Min(array);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Double Min: LINQ", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void BurstLinq()
        {
            Measure.Method(() =>
            {
                BurstLinqExtensions.Min(array);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Double Min: BurstLinq", SampleUnit.Microsecond))
            .Run();
        }
    }

    public class BenchmarkIntMin
    {
        const int WarmupCount = 5;
        const int MeasurementCount = 100;

        static readonly int[] array = Enumerable.Range(0, 10000).ToArray();

        [TearDown]
        public void TearDown()
        {
            GC.Collect();
        }

        [Test, Performance]
        public void For()
        {
            Measure.Method(() =>
            {
                if (array == null) return;

                var result = int.MaxValue;
                for (int i = 0; i < array.Length; i++)
                {
                    if (array[i] < result) result = array[i];
                }
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int Min: For", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void LINQ()
        {
            Measure.Method(() =>
            {
                Enumerable.Min(array);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int Min: LINQ", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void BurstLinq()
        {
            Measure.Method(() =>
            {
                BurstLinqExtensions.Min(array);
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int Min: BurstLinq", SampleUnit.Microsecond))
            .Run();
        }
    }


    public class BenchmarkIntContains
    {
        const int WarmupCount = 5;
        const int MeasurementCount = 100;

        static readonly int[] array = Enumerable.Range(0, 10000).ToArray();

        [TearDown]
        public void TearDown()
        {
            GC.Collect();
        }

        [Test, Performance]
        public void For()
        {
            Measure.Method(() =>
            {
                if (array == null) return;

                var value = array.Last();
                var result = false;
                for (int i = 0; i < array.Length; i++)
                {
                    if (array[i] == value)
                    {
                        result = true;
                        break;
                    }
                }
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int Contains: For", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void LINQ()
        {
            Measure.Method(() =>
            {
                Enumerable.Contains(array, array.Last());
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int Contains: LINQ", SampleUnit.Microsecond))
            .Run();
        }

        [Test, Performance]
        public void BurstLinq()
        {
            Measure.Method(() =>
            {
                BurstLinqExtensions.Contains(array, array.Last());
            })
            .WarmupCount(WarmupCount)
            .MeasurementCount(MeasurementCount)
            .SampleGroup(new SampleGroup("Int Contains: BurstLinq", SampleUnit.Microsecond))
            .Run();
        }
    }

}

#pragma warning restore CS0219

================================================
FILE: Assets/BurstLinq/Tests/Runtime/Benchmark.cs.meta
================================================
fileFormatVersion: 2
guid: 1d39bdb98ccf048429c5c1c5a933bc6f
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/BurstLinq.Tests.Runtime.asmdef
================================================
{
    "name": "BurstLinq.Tests.Runtime",
    "rootNamespace": "BurstLinq.Tests",
    "references": [
        "UnityEngine.TestRunner",
        "UnityEditor.TestRunner",
        "Unity.PerformanceTesting",
        "Unity.Mathematics",
        "Unity.Collections",
        "BurstLinq"
    ],
    "includePlatforms": [],
    "excludePlatforms": [],
    "allowUnsafeCode": false,
    "overrideReferences": true,
    "precompiledReferences": [
        "nunit.framework.dll"
    ],
    "autoReferenced": false,
    "defineConstraints": [
        "UNITY_INCLUDE_TESTS"
    ],
    "versionDefines": [],
    "noEngineReferences": false
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/BurstLinq.Tests.Runtime.asmdef.meta
================================================
fileFormatVersion: 2
guid: 3091443d419f943faae76bebd1e7ac5f
AssemblyDefinitionImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/ContainsTest.cs
================================================
using System;
using System.Linq;
using System.Runtime.InteropServices;
using NUnit.Framework;
using UnityEngine;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class ContainsTest
    {
        const int IterationCount = 1000;

        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_Contains_Int_List()
        {
            for (int i = 0; i < IterationCount; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();
                var value = Random.Range(0, 2) == 0 ? 50 : -1;

                var result1 = Enumerable.Contains(list, value);
                var result2 = BurstLinqExtensions.Contains(list, value);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Contains_Int_Array()
        {
            for (int i = 0; i < IterationCount; i++)
            {
                var array = RandomEnumerable.RepeatInt(0, 100, 100).ToArray();
                var value = Random.Range(0, 2) == 0 ? 50 : -1;

                var result1 = Enumerable.Contains(array, value);
                var result2 = BurstLinqExtensions.Contains(array, value);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Contains_Float_Array()
        {
            for (int i = 0; i < IterationCount; i++)
            {
                var array = RandomEnumerable.RepeatFloat(0f, 100f, 1000).ToArray();
                var value = Random.Range(0, 2) == 0 ? 50f : -1f;

                var result1 = Enumerable.Contains(array, value);
                var result2 = BurstLinqExtensions.Contains(array, value);

                Assert.AreEqual(result1, result2);
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/ContainsTest.cs.meta
================================================
fileFormatVersion: 2
guid: c667f33a822124332b2f9d372526724e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/MaxTest.cs
================================================
using System;
using System.Linq;
using NUnit.Framework;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class MaxTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 1000; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Max(list);
                var result2 = BurstLinqExtensions.Max(list);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Byte()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatByte(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_SByte()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatSByte(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Short()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatShort(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UShort()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUShort(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Long()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatLong(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_ULong()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatULong(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/MaxTest.cs.meta
================================================
fileFormatVersion: 2
guid: 37fd8c825ce154f449e852fea235633e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/MaxTest.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    string GetTypeName(string typeName)
    {
        if (typeName[0] == 'u') return "U" + char.ToUpper(typeName[1]) + typeName.Substring(2);
        if (typeName == "sbyte") return "SByte";
        return char.ToUpper(typeName[0]) + typeName.Substring(1);
    }

    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double"
    };
#>
using System;
using System.Linq;
using NUnit.Framework;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class MaxTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 1000; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Max(list);
                var result2 = BurstLinqExtensions.Max(list);

                Assert.AreEqual(result1, result2);
            }
        }

<# foreach(var type in types) { #>
        [Test]
        public void Test_Array_<#=GetTypeName(type)#>()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.Repeat<#=GetTypeName(type)#>(0, 100, 1000).ToArray();

                var result1 = Enumerable.Max(array);
                var result2 = BurstLinqExtensions.Max(array);

                Assert.AreEqual(result1, result2);
            }
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/MaxTest.tt.meta
================================================
fileFormatVersion: 2
guid: 0407dc155148540d5a8ad6a1a9695d9c
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/MinTest.cs
================================================
using System;
using System.Linq;
using NUnit.Framework;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class MinTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 1000; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Min(list);
                var result2 = BurstLinqExtensions.Min(list);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Byte()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatByte(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_SByte()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatSByte(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Short()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatShort(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UShort()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUShort(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Long()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatLong(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_ULong()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatULong(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/MinTest.cs.meta
================================================
fileFormatVersion: 2
guid: 09b6c4f1dba244af19367d039be910f7
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/MinTest.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    string GetTypeName(string typeName)
    {
        if (typeName[0] == 'u') return "U" + char.ToUpper(typeName[1]) + typeName.Substring(2);
        if (typeName == "sbyte") return "SByte";
        return char.ToUpper(typeName[0]) + typeName.Substring(1);
    }

    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double"
    };
#>
using System;
using System.Linq;
using NUnit.Framework;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class MinTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 1000; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Min(list);
                var result2 = BurstLinqExtensions.Min(list);

                Assert.AreEqual(result1, result2);
            }
        }

<# foreach(var type in types) { #>
        [Test]
        public void Test_Array_<#=GetTypeName(type)#>()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.Repeat<#=GetTypeName(type)#>(0, 100, 1000).ToArray();

                var result1 = Enumerable.Min(array);
                var result2 = BurstLinqExtensions.Min(array);

                Assert.AreEqual(result1, result2);
            }
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/MinTest.tt.meta
================================================
fileFormatVersion: 2
guid: 56d0dea43820d4f1fa307da050280f15
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/RandomEnumerable.cs
================================================
using System;
using System.Collections.Generic;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public static class RandomEnumerable
    {

        public static IEnumerable<Vector2> RepeatVector2(float min, float max, int count)
        {
            var minVector = new Vector2(min, min);
            var maxVector = new Vector2(max, max);
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextFloat2(UnsafeUtility.As<Vector2, float2>(ref minVector), UnsafeUtility.As<Vector2, float2>(ref maxVector));
                yield return UnsafeUtility.As<float2, Vector2>(ref value);
            }
        }

        public static IEnumerable<Vector2> RepeatVector2(Vector2 min, Vector2 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextFloat2(UnsafeUtility.As<Vector2, float2>(ref min), UnsafeUtility.As<Vector2, float2>(ref max));
                yield return UnsafeUtility.As<float2, Vector2>(ref value);
            }
        }

        public static IEnumerable<Vector3> RepeatVector3(float min, float max, int count)
        {
            var minVector = new Vector3(min, min, min);
            var maxVector = new Vector3(max, max, max);
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextFloat3(UnsafeUtility.As<Vector3, float3>(ref minVector), UnsafeUtility.As<Vector3, float3>(ref maxVector));
                yield return UnsafeUtility.As<float3, Vector3>(ref value);
            }
        }

        public static IEnumerable<Vector3> RepeatVector3(Vector3 min, Vector3 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextFloat3(UnsafeUtility.As<Vector3, float3>(ref min), UnsafeUtility.As<Vector3, float3>(ref max));
                yield return UnsafeUtility.As<float3, Vector3>(ref value);
            }
        }

        public static IEnumerable<Vector4> RepeatVector4(float min, float max, int count)
        {
            var minVector = new Vector4(min, min, min, min);
            var maxVector = new Vector4(max, max, max, max);
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextFloat4(UnsafeUtility.As<Vector4, float4>(ref minVector), UnsafeUtility.As<Vector4, float4>(ref maxVector));
                yield return UnsafeUtility.As<float4, Vector4>(ref value);
            }
        }

        public static IEnumerable<Vector4> RepeatVector4(Vector4 min, Vector4 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextFloat4(UnsafeUtility.As<Vector4, float4>(ref min), UnsafeUtility.As<Vector4, float4>(ref max));
                yield return UnsafeUtility.As<float4, Vector4>(ref value);
            }
        }

        public static IEnumerable<Vector3Int> RepeatVector3Int(int min, int max, int count)
        {
            var minVector = new Vector3Int(min, min, min);
            var maxVector = new Vector3Int(max, max, max);
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextUInt3(UnsafeUtility.As<Vector3Int, uint3>(ref minVector), UnsafeUtility.As<Vector3Int, uint3>(ref maxVector));
                yield return UnsafeUtility.As<uint3, Vector3Int>(ref value);
            }
        }

        public static IEnumerable<Vector3Int> RepeatVector3Int(Vector3Int min, Vector3Int max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextUInt3(UnsafeUtility.As<Vector3Int, uint3>(ref min), UnsafeUtility.As<Vector3Int, uint3>(ref max));
                yield return UnsafeUtility.As<uint3, Vector3Int>(ref value);
            }
        }

        public static IEnumerable<Vector2Int> RepeatVector2Int(int min, int max, int count)
        {
            var minVector = new Vector2Int(min, min);
            var maxVector = new Vector2Int(max, max);
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextUInt2(UnsafeUtility.As<Vector2Int, uint2>(ref minVector), UnsafeUtility.As<Vector2Int, uint2>(ref maxVector));
                yield return UnsafeUtility.As<uint2, Vector2Int>(ref value);
            }
        }

        public static IEnumerable<Vector2Int> RepeatVector2Int(Vector2Int min, Vector2Int max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                var value = random.NextUInt2(UnsafeUtility.As<Vector2Int, uint2>(ref min), UnsafeUtility.As<Vector2Int, uint2>(ref max));
                yield return UnsafeUtility.As<uint2, Vector2Int>(ref value);
            }
        }

        public static IEnumerable<byte> RepeatByte(byte min, byte max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return (byte)random.NextInt(min, max);
            }
        }

        public static IEnumerable<sbyte> RepeatSByte(sbyte min, sbyte max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return (sbyte)random.NextInt(min, max);
            }
        }

        public static IEnumerable<short> RepeatShort(short min, short max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return (short)random.NextInt(min, max);
            }
        }

        public static IEnumerable<ushort> RepeatUShort(ushort min, ushort max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return (ushort)random.NextInt(min, max);
            }
        }

        public static IEnumerable<uint> RepeatUInt(uint min, uint max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextUInt(min, max);
            }
        }

        public static IEnumerable<uint2> RepeatUInt2(uint2 min, uint2 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextUInt2(min, max);
            }
        }

        public static IEnumerable<uint3> RepeatUInt3(uint3 min, uint3 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextUInt3(min, max);
            }
        }

        public static IEnumerable<uint4> RepeatUInt4(uint4 min, uint4 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextUInt4(min, max);
            }
        }

        public static IEnumerable<long> RepeatLong(long min, long max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextInt((int)min, (int)max);
            }
        }

        public static IEnumerable<ulong> RepeatULong(ulong min, ulong max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextUInt((uint)min, (uint)max);
            }
        }

        public static IEnumerable<int> RepeatInt(int min, int max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextInt(min, max);
            }
        }

        public static IEnumerable<int2> RepeatInt2(int2 min, int2 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextInt2(min, max);
            }
        }

        public static IEnumerable<int3> RepeatInt3(int3 min, int3 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextInt3(min, max);
            }
        }

        public static IEnumerable<int4> RepeatInt4(int4 min, int4 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextInt4(min, max);
            }
        }

        public static IEnumerable<float> RepeatFloat(float min, float max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextFloat(min, max);
            }
        }

        public static IEnumerable<float2> RepeatFloat2(float2 min, float2 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextFloat2(min, max);
            }
        }

        public static IEnumerable<float3> RepeatFloat3(float3 min, float3 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextFloat3(min, max);
            }
        }

        public static IEnumerable<float4> RepeatFloat4(float4 min, float4 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextFloat4(min, max);
            }
        }

        public static IEnumerable<double> RepeatDouble(double min, double max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextDouble(min, max);
            }
        }

        public static IEnumerable<double2> RepeatDouble2(double2 min, double2 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextDouble2(min, max);
            }
        }

        public static IEnumerable<double3> RepeatDouble3(double3 min, double3 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextDouble3(min, max);
            }
        }

        public static IEnumerable<double4> RepeatDouble4(double4 min, double4 max, int count)
        {
            var random = new Unity.Mathematics.Random((uint)Random.Range(0, int.MaxValue));
            for (int i = 0; i < count; i++)
            {
                yield return random.NextDouble4(min, max);
            }
        }
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/RandomEnumerable.cs.meta
================================================
fileFormatVersion: 2
guid: 3ba11c532da2d473b8b8076083d9ff6a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/SequenceEqualTest.cs
================================================
using System;
using System.Linq;
using NUnit.Framework;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class SequenceEqualTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 100; i++)
            {
                var list1 = RandomEnumerable.RepeatInt(0, 2, 10).ToList();
                var list2 = RandomEnumerable.RepeatInt(0, 2, 10).ToList();

                var result1 = Enumerable.SequenceEqual(list1, list2);
                var result2 = BurstLinqExtensions.SequenceEqual(list1, list2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Byte()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatByte(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatByte(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_SByte()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatSByte(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatSByte(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Short()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatShort(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatShort(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UShort()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatUShort(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatUShort(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatInt(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatInt(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatUInt(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatUInt(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Long()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatLong(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatLong(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_ULong()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatULong(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatULong(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatFloat(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatFloat(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatDouble(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatDouble(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatVector2(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatVector2(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector2Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatVector2Int(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatVector2Int(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatVector3(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatVector3(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector3Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatVector3Int(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatVector3Int(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatVector4(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatVector4(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatInt2(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatInt2(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatInt3(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatInt3(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatInt4(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatInt4(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatUInt2(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatUInt2(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatUInt3(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatUInt3(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatUInt4(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatUInt4(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatFloat2(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatFloat2(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatFloat3(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatFloat3(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatFloat4(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatFloat4(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatDouble2(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatDouble2(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatDouble3(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatDouble3(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.RepeatDouble4(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.RepeatDouble4(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

    }
}


================================================
FILE: Assets/BurstLinq/Tests/Runtime/SequenceEqualTest.cs.meta
================================================
fileFormatVersion: 2
guid: 94d745d244014480caeeb7ce8941916e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/SequenceEqualTest.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    string GetTypeName(string typeName)
    {
        if (typeName[0] == 'u') return "U" + char.ToUpper(typeName[1]) + typeName.Substring(2);
        if (typeName == "sbyte") return "SByte";
        return char.ToUpper(typeName[0]) + typeName.Substring(1);
    }

    var types = new string[]
    {
        "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
#>
using System;
using System.Linq;
using NUnit.Framework;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class SequenceEqualTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 100; i++)
            {
                var list1 = RandomEnumerable.RepeatInt(0, 2, 10).ToList();
                var list2 = RandomEnumerable.RepeatInt(0, 2, 10).ToList();

                var result1 = Enumerable.SequenceEqual(list1, list2);
                var result2 = BurstLinqExtensions.SequenceEqual(list1, list2);

                Assert.AreEqual(result1, result2);
            }
        }

<# foreach(var type in types) { #>
        [Test]
        public void Test_Array_<#=GetTypeName(type)#>()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array1 = RandomEnumerable.Repeat<#=GetTypeName(type)#>(0, 2, 10).ToArray();
                var array2 = RandomEnumerable.Repeat<#=GetTypeName(type)#>(0, 2, 10).ToArray();

                var result1 = Enumerable.SequenceEqual(array1, array2);
                var result2 = BurstLinqExtensions.SequenceEqual(array1, array2);

                Assert.AreEqual(result1, result2);
            }
        }

<# } #>
    }
}


================================================
FILE: Assets/BurstLinq/Tests/Runtime/SequenceEqualTest.tt.meta
================================================
fileFormatVersion: 2
guid: e7566cc4bcab64f6d844a81af29ff526
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/SumTest.cs
================================================
using System;
using System.Linq;
using NUnit.Framework;
using Unity.Mathematics;
using UnityEngine;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class SumTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 1000; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Sum(list);
                var result2 = BurstLinqExtensions.Sum(list);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt(0, 100, 1000).ToArray();

                var result1 = Enumerable.Sum(array);
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt(0, 100, 1000).ToArray();

                uint result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Long()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatLong(0, 100, 1000).ToArray();

                var result1 = Enumerable.Sum(array);
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_ULong()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatULong(0, 100, 1000).ToArray();

                ulong result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat(0, 100, 1000).ToArray();

                var result1 = Enumerable.Sum(array);
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble(0, 100, 1000).ToArray();

                var result1 = Enumerable.Sum(array);
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector2(0, 100, 1000).ToArray();

                Vector2 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector2Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector2Int(0, 100, 1000).ToArray();

                Vector2Int result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector3(0, 100, 1000).ToArray();

                Vector3 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector3Int()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector3Int(0, 100, 1000).ToArray();

                Vector3Int result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Vector4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatVector4(0, 100, 1000).ToArray();

                Vector4 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt2(0, 100, 1000).ToArray();

                int2 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt3(0, 100, 1000).ToArray();

                int3 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Int4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatInt4(0, 100, 1000).ToArray();

                int4 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt2(0, 100, 1000).ToArray();

                uint2 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt3(0, 100, 1000).ToArray();

                uint3 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_UInt4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatUInt4(0, 100, 1000).ToArray();

                uint4 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                Assert.AreEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat2(0, 100, 1000).ToArray();

                float2 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat3(0, 100, 1000).ToArray();

                float3 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Float4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatFloat4(0, 100, 1000).ToArray();

                float4 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double2()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble2(0, 100, 1000).ToArray();

                double2 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double3()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble3(0, 100, 1000).ToArray();

                double3 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

        [Test]
        public void Test_Array_Double4()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.RepeatDouble4(0, 100, 1000).ToArray();

                double4 result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);

                AssertEx.AreApproximatelyEqual(result1, result2);
            }
        }

    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/SumTest.cs.meta
================================================
fileFormatVersion: 2
guid: a4294f56768c24a19aef47ed0630569c
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime/SumTest.tt
================================================
<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".cs" #>
<#
    string GetTypeName(string typeName)
    {
        if (typeName[0] == 'u') return "U" + char.ToUpper(typeName[1]) + typeName.Substring(2);
        if (typeName == "sbyte") return "SByte";
        return char.ToUpper(typeName[0]) + typeName.Substring(1);
    }

    bool IsLinqSupport(string typeName)
    {
        return typeName is "int" or "long" or "float" or "double";
    }

    bool IsFloat(string typeName)
    {
        return typeName is "float" or "float2" or "float3" or "float4"
            or "double" or "double2" or "double3" or "double4"
            or "Vector2" or "Vector3" or "Vector4";
    }

    var types = new string[]
    {
        "int", "uint", "long", "ulong", "float", "double",
        "Vector2", "Vector2Int", "Vector3", "Vector3Int", "Vector4",
        "int2", "int3", "int4",
        "uint2", "uint3", "uint4",
        "float2", "float3", "float4",
        "double2", "double3", "double4",
    };
#>
using System;
using System.Linq;
using NUnit.Framework;
using Unity.Mathematics;
using UnityEngine;
using Assert = UnityEngine.Assertions.Assert;
using Random = UnityEngine.Random;

namespace BurstLinq.Tests
{
    public class SumTest
    {
        [SetUp]
        public void SetUp()
        {
            Random.InitState((int)DateTime.Now.Ticks);
        }

        [Test]
        public void Test_List()
        {
            for (int i = 0; i < 1000; i++)
            {
                var list = RandomEnumerable.RepeatInt(0, 100, 1000).ToList();

                var result1 = Enumerable.Sum(list);
                var result2 = BurstLinqExtensions.Sum(list);

                Assert.AreEqual(result1, result2);
            }
        }

<# foreach(var type in types) { #>
        [Test]
        public void Test_Array_<#=GetTypeName(type)#>()
        {
            for (int i = 0; i < 1000; i++)
            {
                var array = RandomEnumerable.Repeat<#=GetTypeName(type)#>(0, 100, 1000).ToArray();

<# if (IsLinqSupport(type)) { #>
                var result1 = Enumerable.Sum(array);
                var result2 = BurstLinqExtensions.Sum(array);
<# } else { #>
                <#=type#> result1 = default;
                for (int n = 0; n < array.Length; n++) result1 += array[n];
                var result2 = BurstLinqExtensions.Sum(array);
<# } #>

<# if (IsFloat(type)) { #>
                AssertEx.AreApproximatelyEqual(result1, result2);
<# } else { #>
                Assert.AreEqual(result1, result2);
<# } #>
            }
        }

<# } #>
    }
}

================================================
FILE: Assets/BurstLinq/Tests/Runtime/SumTest.tt.meta
================================================
fileFormatVersion: 2
guid: b60ef8315855e4099ac7d5322be6a5c4
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests/Runtime.meta
================================================
fileFormatVersion: 2
guid: 015f9dfd74a6549a8ba6973215bdec35
folderAsset: yes
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/Tests.meta
================================================
fileFormatVersion: 2
guid: 4ed136c7d2231406f954843969852723
folderAsset: yes
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq/package.json
================================================
{
    "name": "com.annulusgames.burst-linq",
    "version": "1.2.0",
    "displayName": "Burst Linq",
    "description": "Extremely fast LINQ aggregation operations implementation optimized by Burst Compiler",
    "unity": "2020.1",
    "author": {
        "name": "Annulus Games",
        "url": "https://github.com/AnnulusGames"
    }
}

================================================
FILE: Assets/BurstLinq/package.json.meta
================================================
fileFormatVersion: 2
guid: 5f0678f7ba168481590801edce899326
TextScriptImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: Assets/BurstLinq.meta
================================================
fileFormatVersion: 2
guid: d0bc2035faf064fc9b39816314a001d7
folderAsset: yes
DefaultImporter:
  externalObjects: {}
  userData: 
  assetBundleName: 
  assetBundleVariant: 


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2023 Annulus Games

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: Packages/manifest.json
================================================
{
  "dependencies": {
    "com.unity.collab-proxy": "2.2.0",
    "com.unity.collections": "2.1.4",
    "com.unity.feature.development": "1.0.1",
    "com.unity.ide.visualstudio": "2.0.22",
    "com.unity.test-framework.performance": "3.0.3",
    "com.unity.textmeshpro": "3.0.6",
    "com.unity.timeline": "1.7.5",
    "com.unity.toolchain.macos-arm64-linux-x86_64": "2.0.0",
    "com.unity.ugui": "1.0.0",
    "com.unity.visualscripting": "1.8.0",
    "com.unity.modules.ai": "1.0.0",
    "com.unity.modules.androidjni": "1.0.0",
    "com.unity.modules.animation": "1.0.0",
    "com.unity.modules.assetbundle": "1.0.0",
    "com.unity.modules.audio": "1.0.0",
    "com.unity.modules.cloth": "1.0.0",
    "com.unity.modules.director": "1.0.0",
    "com.unity.modules.imageconversion": "1.0.0",
    "com.unity.modules.imgui": "1.0.0",
    "com.unity.modules.jsonserialize": "1.0.0",
    "com.unity.modules.particlesystem": "1.0.0",
    "com.unity.modules.physics": "1.0.0",
    "com.unity.modules.physics2d": "1.0.0",
    "com.unity.modules.screencapture": "1.0.0",
    "com.unity.modules.terrain": "1.0.0",
    "com.unity.modules.terrainphysics": "1.0.0",
    "com.unity.modules.tilemap": "1.0.0",
    "com.unity.modules.ui": "1.0.0",
    "com.unity.modules.uielements": "1.0.0",
    "com.unity.modules.umbra": "1.0.0",
    "com.unity.modules.unityanalytics": "1.0.0",
    "com.unity.modules.unitywebrequest": "1.0.0",
    "com.unity.modules.unitywebrequestassetbundle": "1.0.0",
    "com.unity.modules.unitywebrequestaudio": "1.0.0",
    "com.unity.modules.unitywebrequesttexture": "1.0.0",
    "com.unity.modules.unitywebrequestwww": "1.0.0",
    "com.unity.modules.vehicles": "1.0.0",
    "com.unity.modules.video": "1.0.0",
    "com.unity.modules.vr": "1.0.0",
    "com.unity.modules.wind": "1.0.0",
    "com.unity.modules.xr": "1.0.0"
  }
}


================================================
FILE: Packages/packages-lock.json
================================================
{
  "dependencies": {
    "com.unity.burst": {
      "version": "1.8.7",
      "depth": 1,
      "source": "registry",
      "dependencies": {
        "com.unity.mathematics": "1.2.1"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.collab-proxy": {
      "version": "2.2.0",
      "depth": 0,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.collections": {
      "version": "2.1.4",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.burst": "1.8.4",
        "com.unity.modules.unityanalytics": "1.0.0",
        "com.unity.nuget.mono-cecil": "1.11.4"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.editorcoroutines": {
      "version": "1.0.0",
      "depth": 1,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.ext.nunit": {
      "version": "1.0.6",
      "depth": 2,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.feature.development": {
      "version": "1.0.1",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.ide.visualstudio": "2.0.18",
        "com.unity.ide.rider": "3.0.24",
        "com.unity.ide.vscode": "1.2.5",
        "com.unity.editorcoroutines": "1.0.0",
        "com.unity.performance.profile-analyzer": "1.2.2",
        "com.unity.test-framework": "1.1.33",
        "com.unity.testtools.codecoverage": "1.2.4"
      }
    },
    "com.unity.ide.rider": {
      "version": "3.0.24",
      "depth": 1,
      "source": "registry",
      "dependencies": {
        "com.unity.ext.nunit": "1.0.6"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.ide.visualstudio": {
      "version": "2.0.22",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.test-framework": "1.1.9"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.ide.vscode": {
      "version": "1.2.5",
      "depth": 1,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.mathematics": {
      "version": "1.2.6",
      "depth": 2,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.nuget.mono-cecil": {
      "version": "1.11.4",
      "depth": 1,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.performance.profile-analyzer": {
      "version": "1.2.2",
      "depth": 1,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.settings-manager": {
      "version": "2.0.1",
      "depth": 2,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.sysroot": {
      "version": "2.0.7",
      "depth": 1,
      "source": "registry",
      "dependencies": {},
      "url": "https://packages.unity.com"
    },
    "com.unity.sysroot.linux-x86_64": {
      "version": "2.0.6",
      "depth": 1,
      "source": "registry",
      "dependencies": {
        "com.unity.sysroot": "2.0.7"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.test-framework": {
      "version": "1.1.33",
      "depth": 1,
      "source": "registry",
      "dependencies": {
        "com.unity.ext.nunit": "1.0.6",
        "com.unity.modules.imgui": "1.0.0",
        "com.unity.modules.jsonserialize": "1.0.0"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.test-framework.performance": {
      "version": "3.0.3",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.test-framework": "1.1.31",
        "com.unity.modules.jsonserialize": "1.0.0"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.testtools.codecoverage": {
      "version": "1.2.4",
      "depth": 1,
      "source": "registry",
      "dependencies": {
        "com.unity.test-framework": "1.0.16",
        "com.unity.settings-manager": "1.0.1"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.textmeshpro": {
      "version": "3.0.6",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.ugui": "1.0.0"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.timeline": {
      "version": "1.7.5",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.modules.director": "1.0.0",
        "com.unity.modules.animation": "1.0.0",
        "com.unity.modules.audio": "1.0.0",
        "com.unity.modules.particlesystem": "1.0.0"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.toolchain.macos-arm64-linux-x86_64": {
      "version": "2.0.0",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.sysroot": "2.0.7",
        "com.unity.sysroot.linux-x86_64": "2.0.6"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.ugui": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.ui": "1.0.0",
        "com.unity.modules.imgui": "1.0.0"
      }
    },
    "com.unity.visualscripting": {
      "version": "1.8.0",
      "depth": 0,
      "source": "registry",
      "dependencies": {
        "com.unity.ugui": "1.0.0",
        "com.unity.modules.jsonserialize": "1.0.0"
      },
      "url": "https://packages.unity.com"
    },
    "com.unity.modules.ai": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.androidjni": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.animation": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.assetbundle": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.audio": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.cloth": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.physics": "1.0.0"
      }
    },
    "com.unity.modules.director": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.audio": "1.0.0",
        "com.unity.modules.animation": "1.0.0"
      }
    },
    "com.unity.modules.imageconversion": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.imgui": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.jsonserialize": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.particlesystem": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.physics": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.physics2d": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.screencapture": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.imageconversion": "1.0.0"
      }
    },
    "com.unity.modules.subsystems": {
      "version": "1.0.0",
      "depth": 1,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.jsonserialize": "1.0.0"
      }
    },
    "com.unity.modules.terrain": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.terrainphysics": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.physics": "1.0.0",
        "com.unity.modules.terrain": "1.0.0"
      }
    },
    "com.unity.modules.tilemap": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.physics2d": "1.0.0"
      }
    },
    "com.unity.modules.ui": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.uielements": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.ui": "1.0.0",
        "com.unity.modules.imgui": "1.0.0",
        "com.unity.modules.jsonserialize": "1.0.0"
      }
    },
    "com.unity.modules.umbra": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.unityanalytics": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.unitywebrequest": "1.0.0",
        "com.unity.modules.jsonserialize": "1.0.0"
      }
    },
    "com.unity.modules.unitywebrequest": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.unitywebrequestassetbundle": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.assetbundle": "1.0.0",
        "com.unity.modules.unitywebrequest": "1.0.0"
      }
    },
    "com.unity.modules.unitywebrequestaudio": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.unitywebrequest": "1.0.0",
        "com.unity.modules.audio": "1.0.0"
      }
    },
    "com.unity.modules.unitywebrequesttexture": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.unitywebrequest": "1.0.0",
        "com.unity.modules.imageconversion": "1.0.0"
      }
    },
    "com.unity.modules.unitywebrequestwww": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.unitywebrequest": "1.0.0",
        "com.unity.modules.unitywebrequestassetbundle": "1.0.0",
        "com.unity.modules.unitywebrequestaudio": "1.0.0",
        "com.unity.modules.audio": "1.0.0",
        "com.unity.modules.assetbundle": "1.0.0",
        "com.unity.modules.imageconversion": "1.0.0"
      }
    },
    "com.unity.modules.vehicles": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.physics": "1.0.0"
      }
    },
    "com.unity.modules.video": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.audio": "1.0.0",
        "com.unity.modules.ui": "1.0.0",
        "com.unity.modules.unitywebrequest": "1.0.0"
      }
    },
    "com.unity.modules.vr": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.jsonserialize": "1.0.0",
        "com.unity.modules.physics": "1.0.0",
        "com.unity.modules.xr": "1.0.0"
      }
    },
    "com.unity.modules.wind": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {}
    },
    "com.unity.modules.xr": {
      "version": "1.0.0",
      "depth": 0,
      "source": "builtin",
      "dependencies": {
        "com.unity.modules.physics": "1.0.0",
        "com.unity.modules.jsonserialize": "1.0.0",
        "com.unity.modules.subsystems": "1.0.0"
      }
    }
  }
}


================================================
FILE: ProjectSettings/AudioManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!11 &1
AudioManager:
  m_ObjectHideFlags: 0
  serializedVersion: 2
  m_Volume: 1
  Rolloff Scale: 1
  Doppler Factor: 1
  Default Speaker Mode: 2
  m_SampleRate: 0
  m_DSPBufferSize: 1024
  m_VirtualVoiceCount: 512
  m_RealVoiceCount: 32
  m_SpatializerPlugin: 
  m_AmbisonicDecoderPlugin: 
  m_DisableAudio: 0
  m_VirtualizeEffects: 1
  m_RequestedDSPBufferSize: 1024


================================================
FILE: ProjectSettings/BurstAotSettings_StandaloneOSX.json
================================================
{
  "MonoBehaviour": {
    "Version": 4,
    "EnableBurstCompilation": true,
    "EnableOptimisations": true,
    "EnableSafetyChecks": false,
    "EnableDebugInAllBuilds": false,
    "DebugDataKind": 1,
    "EnableArmv9SecurityFeatures": false,
    "CpuMinTargetX32": 0,
    "CpuMaxTargetX32": 0,
    "CpuMinTargetX64": 0,
    "CpuMaxTargetX64": 0,
    "CpuTargetsX64": 72,
    "OptimizeFor": 0
  }
}


================================================
FILE: ProjectSettings/ClusterInputManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!236 &1
ClusterInputManager:
  m_ObjectHideFlags: 0
  m_Inputs: []


================================================
FILE: ProjectSettings/CommonBurstAotSettings.json
================================================
{
  "MonoBehaviour": {
    "Version": 4,
    "DisabledWarnings": ""
  }
}


================================================
FILE: ProjectSettings/DynamicsManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!55 &1
PhysicsManager:
  m_ObjectHideFlags: 0
  serializedVersion: 11
  m_Gravity: {x: 0, y: -9.81, z: 0}
  m_DefaultMaterial: {fileID: 0}
  m_BounceThreshold: 2
  m_SleepThreshold: 0.005
  m_DefaultContactOffset: 0.01
  m_DefaultSolverIterations: 6
  m_DefaultSolverVelocityIterations: 1
  m_QueriesHitBackfaces: 0
  m_QueriesHitTriggers: 1
  m_EnableAdaptiveForce: 0
  m_ClothInterCollisionDistance: 0
  m_ClothInterCollisionStiffness: 0
  m_ContactsGeneration: 1
  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
  m_AutoSimulation: 1
  m_AutoSyncTransforms: 0
  m_ReuseCollisionCallbacks: 1
  m_ClothInterCollisionSettingsToggle: 0
  m_ContactPairsMode: 0
  m_BroadphaseType: 0
  m_WorldBounds:
    m_Center: {x: 0, y: 0, z: 0}
    m_Extent: {x: 250, y: 250, z: 250}
  m_WorldSubdivisions: 8
  m_FrictionType: 0
  m_EnableEnhancedDeterminism: 0
  m_EnableUnifiedHeightmaps: 1
  m_DefaultMaxAngluarSpeed: 7


================================================
FILE: ProjectSettings/EditorBuildSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!1045 &1
EditorBuildSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 2
  m_Scenes: []
  m_configObjects: {}


================================================
FILE: ProjectSettings/EditorSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!159 &1
EditorSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 12
  m_SerializationMode: 2
  m_LineEndingsForNewScripts: 0
  m_DefaultBehaviorMode: 0
  m_PrefabRegularEnvironment: {fileID: 0}
  m_PrefabUIEnvironment: {fileID: 0}
  m_SpritePackerMode: 0
  m_SpritePackerCacheSize: 10
  m_SpritePackerPaddingPower: 1
  m_Bc7TextureCompressor: 0
  m_EtcTextureCompressorBehavior: 1
  m_EtcTextureFastCompressor: 1
  m_EtcTextureNormalCompressor: 2
  m_EtcTextureBestCompressor: 4
  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp;asmref
  m_ProjectGenerationRootNamespace: 
  m_EnableTextureStreamingInEditMode: 1
  m_EnableTextureStreamingInPlayMode: 1
  m_EnableEditorAsyncCPUTextureLoading: 0
  m_AsyncShaderCompilation: 1
  m_PrefabModeAllowAutoSave: 1
  m_EnterPlayModeOptionsEnabled: 1
  m_EnterPlayModeOptions: 3
  m_GameObjectNamingDigits: 1
  m_GameObjectNamingScheme: 0
  m_AssetNamingUsesSpace: 1
  m_InspectorUseIMGUIDefaultInspector: 0
  m_UseLegacyProbeSampleCount: 0
  m_SerializeInlineMappingsOnOneLine: 1
  m_DisableCookiesInLightmapper: 0
  m_AssetPipelineMode: 1
  m_RefreshImportMode: 0
  m_CacheServerMode: 0
  m_CacheServerEndpoint: 
  m_CacheServerNamespacePrefix: default
  m_CacheServerEnableDownload: 1
  m_CacheServerEnableUpload: 1
  m_CacheServerEnableAuth: 0
  m_CacheServerEnableTls: 0
  m_CacheServerValidationMode: 2
  m_CacheServerDownloadBatchSize: 128
  m_EnableEnlightenBakedGI: 0


================================================
FILE: ProjectSettings/GraphicsSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!30 &1
GraphicsSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 13
  m_Deferred:
    m_Mode: 1
    m_Shader: {fileID: 69, guid: 0000000000000000f000000000000000, type: 0}
  m_DeferredReflections:
    m_Mode: 1
    m_Shader: {fileID: 74, guid: 0000000000000000f000000000000000, type: 0}
  m_ScreenSpaceShadows:
    m_Mode: 1
    m_Shader: {fileID: 64, guid: 0000000000000000f000000000000000, type: 0}
  m_LegacyDeferred:
    m_Mode: 1
    m_Shader: {fileID: 63, guid: 0000000000000000f000000000000000, type: 0}
  m_DepthNormals:
    m_Mode: 1
    m_Shader: {fileID: 62, guid: 0000000000000000f000000000000000, type: 0}
  m_MotionVectors:
    m_Mode: 1
    m_Shader: {fileID: 75, guid: 0000000000000000f000000000000000, type: 0}
  m_LightHalo:
    m_Mode: 1
    m_Shader: {fileID: 105, guid: 0000000000000000f000000000000000, type: 0}
  m_LensFlare:
    m_Mode: 1
    m_Shader: {fileID: 102, guid: 0000000000000000f000000000000000, type: 0}
  m_AlwaysIncludedShaders:
  - {fileID: 7, guid: 0000000000000000f000000000000000, type: 0}
  - {fileID: 15104, guid: 0000000000000000f000000000000000, type: 0}
  - {fileID: 15105, guid: 0000000000000000f000000000000000, type: 0}
  - {fileID: 15106, guid: 0000000000000000f000000000000000, type: 0}
  - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
  - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0}
  m_PreloadedShaders: []
  m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
    type: 0}
  m_CustomRenderPipeline: {fileID: 0}
  m_TransparencySortMode: 0
  m_TransparencySortAxis: {x: 0, y: 0, z: 1}
  m_DefaultRenderingPath: 1
  m_DefaultMobileRenderingPath: 1
  m_TierSettings: []
  m_LightmapStripping: 0
  m_FogStripping: 0
  m_InstancingStripping: 0
  m_LightmapKeepPlain: 1
  m_LightmapKeepDirCombined: 1
  m_LightmapKeepDynamicPlain: 1
  m_LightmapKeepDynamicDirCombined: 1
  m_LightmapKeepShadowMask: 1
  m_LightmapKeepSubtractive: 1
  m_FogKeepLinear: 1
  m_FogKeepExp: 1
  m_FogKeepExp2: 1
  m_AlbedoSwatchInfos: []
  m_LightsUseLinearIntensity: 0
  m_LightsUseColorTemperature: 0
  m_LogWhenShaderIsCompiled: 0
  m_AllowEnlightenSupportForUpgradedProject: 0


================================================
FILE: ProjectSettings/InputManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!13 &1
InputManager:
  m_ObjectHideFlags: 0
  serializedVersion: 2
  m_Axes:
  - serializedVersion: 3
    m_Name: Horizontal
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: left
    positiveButton: right
    altNegativeButton: a
    altPositiveButton: d
    gravity: 3
    dead: 0.001
    sensitivity: 3
    snap: 1
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Vertical
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: down
    positiveButton: up
    altNegativeButton: s
    altPositiveButton: w
    gravity: 3
    dead: 0.001
    sensitivity: 3
    snap: 1
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Fire1
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: left ctrl
    altNegativeButton: 
    altPositiveButton: mouse 0
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Fire2
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: left alt
    altNegativeButton: 
    altPositiveButton: mouse 1
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Fire3
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: left shift
    altNegativeButton: 
    altPositiveButton: mouse 2
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Jump
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: space
    altNegativeButton: 
    altPositiveButton: 
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Mouse X
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: 
    altNegativeButton: 
    altPositiveButton: 
    gravity: 0
    dead: 0
    sensitivity: 0.1
    snap: 0
    invert: 0
    type: 1
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Mouse Y
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: 
    altNegativeButton: 
    altPositiveButton: 
    gravity: 0
    dead: 0
    sensitivity: 0.1
    snap: 0
    invert: 0
    type: 1
    axis: 1
    joyNum: 0
  - serializedVersion: 3
    m_Name: Mouse ScrollWheel
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: 
    altNegativeButton: 
    altPositiveButton: 
    gravity: 0
    dead: 0
    sensitivity: 0.1
    snap: 0
    invert: 0
    type: 1
    axis: 2
    joyNum: 0
  - serializedVersion: 3
    m_Name: Horizontal
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: 
    altNegativeButton: 
    altPositiveButton: 
    gravity: 0
    dead: 0.19
    sensitivity: 1
    snap: 0
    invert: 0
    type: 2
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Vertical
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: 
    altNegativeButton: 
    altPositiveButton: 
    gravity: 0
    dead: 0.19
    sensitivity: 1
    snap: 0
    invert: 1
    type: 2
    axis: 1
    joyNum: 0
  - serializedVersion: 3
    m_Name: Fire1
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: joystick button 0
    altNegativeButton: 
    altPositiveButton: 
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Fire2
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: joystick button 1
    altNegativeButton: 
    altPositiveButton: 
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Fire3
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: joystick button 2
    altNegativeButton: 
    altPositiveButton: 
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Jump
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: joystick button 3
    altNegativeButton: 
    altPositiveButton: 
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Submit
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: return
    altNegativeButton: 
    altPositiveButton: joystick button 0
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Submit
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: enter
    altNegativeButton: 
    altPositiveButton: space
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0
  - serializedVersion: 3
    m_Name: Cancel
    descriptiveName: 
    descriptiveNegativeName: 
    negativeButton: 
    positiveButton: escape
    altNegativeButton: 
    altPositiveButton: joystick button 1
    gravity: 1000
    dead: 0.001
    sensitivity: 1000
    snap: 0
    invert: 0
    type: 0
    axis: 0
    joyNum: 0


================================================
FILE: ProjectSettings/MemorySettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!387306366 &1
MemorySettings:
  m_ObjectHideFlags: 0
  m_EditorMemorySettings:
    m_MainAllocatorBlockSize: -1
    m_ThreadAllocatorBlockSize: -1
    m_MainGfxBlockSize: -1
    m_ThreadGfxBlockSize: -1
    m_CacheBlockSize: -1
    m_TypetreeBlockSize: -1
    m_ProfilerBlockSize: -1
    m_ProfilerEditorBlockSize: -1
    m_BucketAllocatorGranularity: -1
    m_BucketAllocatorBucketsCount: -1
    m_BucketAllocatorBlockSize: -1
    m_BucketAllocatorBlockCount: -1
    m_ProfilerBucketAllocatorGranularity: -1
    m_ProfilerBucketAllocatorBucketsCount: -1
    m_ProfilerBucketAllocatorBlockSize: -1
    m_ProfilerBucketAllocatorBlockCount: -1
    m_TempAllocatorSizeMain: -1
    m_JobTempAllocatorBlockSize: -1
    m_BackgroundJobTempAllocatorBlockSize: -1
    m_JobTempAllocatorReducedBlockSize: -1
    m_TempAllocatorSizeGIBakingWorker: -1
    m_TempAllocatorSizeNavMeshWorker: -1
    m_TempAllocatorSizeAudioWorker: -1
    m_TempAllocatorSizeCloudWorker: -1
    m_TempAllocatorSizeGfx: -1
    m_TempAllocatorSizeJobWorker: -1
    m_TempAllocatorSizeBackgroundWorker: -1
    m_TempAllocatorSizePreloadManager: -1
  m_PlatformMemorySettings: {}


================================================
FILE: ProjectSettings/NavMeshAreas.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!126 &1
NavMeshProjectSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 2
  areas:
  - name: Walkable
    cost: 1
  - name: Not Walkable
    cost: 1
  - name: Jump
    cost: 2
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  - name: 
    cost: 1
  m_LastAgentTypeID: -887442657
  m_Settings:
  - serializedVersion: 2
    agentTypeID: 0
    agentRadius: 0.5
    agentHeight: 2
    agentSlope: 45
    agentClimb: 0.75
    ledgeDropHeight: 0
    maxJumpAcrossDistance: 0
    minRegionArea: 2
    manualCellSize: 0
    cellSize: 0.16666667
    manualTileSize: 0
    tileSize: 256
    accuratePlacement: 0
    debug:
      m_Flags: 0
  m_SettingNames:
  - Humanoid


================================================
FILE: ProjectSettings/PackageManagerSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &1
MonoBehaviour:
  m_ObjectHideFlags: 61
  m_CorrespondingSourceObject: {fileID: 0}
  m_PrefabInstance: {fileID: 0}
  m_PrefabAsset: {fileID: 0}
  m_GameObject: {fileID: 0}
  m_Enabled: 1
  m_EditorHideFlags: 0
  m_Script: {fileID: 13964, guid: 0000000000000000e000000000000000, type: 0}
  m_Name: 
  m_EditorClassIdentifier: 
  m_EnablePreReleasePackages: 0
  m_EnablePackageDependencies: 0
  m_AdvancedSettingsExpanded: 1
  m_ScopedRegistriesSettingsExpanded: 1
  m_SeeAllPackageVersions: 0
  oneTimeWarningShown: 0
  m_Registries:
  - m_Id: main
    m_Name: 
    m_Url: https://packages.unity.com
    m_Scopes: []
    m_IsDefault: 1
    m_Capabilities: 7
  m_UserSelectedRegistryName: 
  m_UserAddingNewScopedRegistry: 0
  m_RegistryInfoDraft:
    m_Modified: 0
    m_ErrorMessage: 
    m_UserModificationsInstanceId: -830
    m_OriginalInstanceId: -832
  m_LoadAssets: 0


================================================
FILE: ProjectSettings/Packages/com.unity.testtools.codecoverage/Settings.json
================================================
{
    "m_Dictionary": {
        "m_DictionaryValues": []
    }
}

================================================
FILE: ProjectSettings/Physics2DSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!19 &1
Physics2DSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 4
  m_Gravity: {x: 0, y: -9.81}
  m_DefaultMaterial: {fileID: 0}
  m_VelocityIterations: 8
  m_PositionIterations: 3
  m_VelocityThreshold: 1
  m_MaxLinearCorrection: 0.2
  m_MaxAngularCorrection: 8
  m_MaxTranslationSpeed: 100
  m_MaxRotationSpeed: 360
  m_BaumgarteScale: 0.2
  m_BaumgarteTimeOfImpactScale: 0.75
  m_TimeToSleep: 0.5
  m_LinearSleepTolerance: 0.01
  m_AngularSleepTolerance: 2
  m_DefaultContactOffset: 0.01
  m_JobOptions:
    serializedVersion: 2
    useMultithreading: 0
    useConsistencySorting: 0
    m_InterpolationPosesPerJob: 100
    m_NewContactsPerJob: 30
    m_CollideContactsPerJob: 100
    m_ClearFlagsPerJob: 200
    m_ClearBodyForcesPerJob: 200
    m_SyncDiscreteFixturesPerJob: 50
    m_SyncContinuousFixturesPerJob: 50
    m_FindNearestContactsPerJob: 100
    m_UpdateTriggerContactsPerJob: 100
    m_IslandSolverCostThreshold: 100
    m_IslandSolverBodyCostScale: 1
    m_IslandSolverContactCostScale: 10
    m_IslandSolverJointCostScale: 10
    m_IslandSolverBodiesPerJob: 50
    m_IslandSolverContactsPerJob: 50
  m_AutoSimulation: 1
  m_QueriesHitTriggers: 1
  m_QueriesStartInColliders: 1
  m_CallbacksOnDisable: 1
  m_ReuseCollisionCallbacks: 1
  m_AutoSyncTransforms: 0
  m_AlwaysShowColliders: 0
  m_ShowColliderSleep: 1
  m_ShowColliderContacts: 0
  m_ShowColliderAABB: 0
  m_ContactArrowScale: 0.2
  m_ColliderAwakeColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.7529412}
  m_ColliderAsleepColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.36078432}
  m_ColliderContactColor: {r: 1, g: 0, b: 1, a: 0.6862745}
  m_ColliderAABBColor: {r: 1, g: 1, b: 0, a: 0.2509804}
  m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff


================================================
FILE: ProjectSettings/PresetManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!1386491679 &1
PresetManager:
  m_ObjectHideFlags: 0
  serializedVersion: 2
  m_DefaultPresets: {}


================================================
FILE: ProjectSettings/ProjectSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!129 &1
PlayerSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 26
  productGUID: 15fdc041956714e4fb8c47bde0aa2e9e
  AndroidProfiler: 0
  AndroidFilterTouchesWhenObscured: 0
  AndroidEnableSustainedPerformanceMode: 0
  defaultScreenOrientation: 4
  targetDevice: 2
  useOnDemandResources: 0
  accelerometerFrequency: 60
  companyName: AnnulusGames
  productName: BurstLinq
  defaultCursor: {fileID: 0}
  cursorHotspot: {x: 0, y: 0}
  m_SplashScreenBackgroundColor: {r: 0.13725491, g: 0.12156863, b: 0.1254902, a: 1}
  m_ShowUnitySplashScreen: 0
  m_ShowUnitySplashLogo: 1
  m_SplashScreenOverlayOpacity: 1
  m_SplashScreenAnimation: 1
  m_SplashScreenLogoStyle: 1
  m_SplashScreenDrawMode: 0
  m_SplashScreenBackgroundAnimationZoom: 1
  m_SplashScreenLogoAnimationZoom: 1
  m_SplashScreenBackgroundLandscapeAspect: 1
  m_SplashScreenBackgroundPortraitAspect: 1
  m_SplashScreenBackgroundLandscapeUvs:
    serializedVersion: 2
    x: 0
    y: 0
    width: 1
    height: 1
  m_SplashScreenBackgroundPortraitUvs:
    serializedVersion: 2
    x: 0
    y: 0
    width: 1
    height: 1
  m_SplashScreenLogos: []
  m_VirtualRealitySplashScreen: {fileID: 0}
  m_HolographicTrackingLossScreen: {fileID: 0}
  defaultScreenWidth: 1920
  defaultScreenHeight: 1080
  defaultScreenWidthWeb: 960
  defaultScreenHeightWeb: 600
  m_StereoRenderingPath: 0
  m_ActiveColorSpace: 0
  m_SpriteBatchVertexThreshold: 300
  m_MTRendering: 1
  mipStripping: 0
  numberOfMipsStripped: 0
  numberOfMipsStrippedPerMipmapLimitGroup: {}
  m_StackTraceTypes: 010000000100000001000000010000000100000001000000
  iosShowActivityIndicatorOnLoading: -1
  androidShowActivityIndicatorOnLoading: -1
  iosUseCustomAppBackgroundBehavior: 0
  allowedAutorotateToPortrait: 1
  allowedAutorotateToPortraitUpsideDown: 1
  allowedAutorotateToLandscapeRight: 1
  allowedAutorotateToLandscapeLeft: 1
  useOSAutorotation: 1
  use32BitDisplayBuffer: 1
  preserveFramebufferAlpha: 0
  disableDepthAndStencilBuffers: 0
  androidStartInFullscreen: 1
  androidRenderOutsideSafeArea: 1
  androidUseSwappy: 1
  androidBlitType: 0
  androidResizableWindow: 0
  androidDefaultWindowWidth: 1920
  androidDefaultWindowHeight: 1080
  androidMinimumWindowWidth: 400
  androidMinimumWindowHeight: 300
  androidFullscreenMode: 1
  defaultIsNativeResolution: 1
  macRetinaSupport: 1
  runInBackground: 1
  captureSingleScreen: 0
  muteOtherAudioSources: 0
  Prepare IOS For Recording: 0
  Force IOS Speakers When Recording: 0
  deferSystemGesturesMode: 0
  hideHomeButton: 0
  submitAnalytics: 1
  usePlayerLog: 1
  bakeCollisionMeshes: 0
  forceSingleInstance: 0
  useFlipModelSwapchain: 1
  resizableWindow: 1
  useMacAppStoreValidation: 0
  macAppStoreCategory: public.app-category.games
  gpuSkinning: 1
  xboxPIXTextureCapture: 0
  xboxEnableAvatar: 0
  xboxEnableKinect: 0
  xboxEnableKinectAutoTracking: 0
  xboxEnableFitness: 0
  visibleInBackground: 1
  allowFullscreenSwitch: 1
  fullscreenMode: 3
  xboxSpeechDB: 0
  xboxEnableHeadOrientation: 0
  xboxEnableGuest: 0
  xboxEnablePIXSampling: 0
  metalFramebufferOnly: 0
  xboxOneResolution: 0
  xboxOneSResolution: 0
  xboxOneXResolution: 3
  xboxOneMonoLoggingLevel: 0
  xboxOneLoggingLevel: 1
  xboxOneDisableEsram: 0
  xboxOneEnableTypeOptimization: 0
  xboxOnePresentImmediateThreshold: 0
  switchQueueCommandMemory: 0
  switchQueueControlMemory: 16384
  switchQueueComputeMemory: 262144
  switchNVNShaderPoolsGranularity: 33554432
  switchNVNDefaultPoolsGranularity: 16777216
  switchNVNOtherPoolsGranularity: 16777216
  switchGpuScratchPoolGranularity: 2097152
  switchAllowGpuScratchShrinking: 0
  switchNVNMaxPublicTextureIDCount: 0
  switchNVNMaxPublicSamplerIDCount: 0
  switchNVNGraphicsFirmwareMemory: 32
  stadiaPresentMode: 0
  stadiaTargetFramerate: 0
  vulkanNumSwapchainBuffers: 3
  vulkanEnableSetSRGBWrite: 0
  vulkanEnablePreTransform: 1
  vulkanEnableLateAcquireNextImage: 0
  vulkanEnableCommandBufferRecycling: 1
  loadStoreDebugModeEnabled: 0
  bundleVersion: 0.1
  preloadedAssets: []
  metroInputSource: 0
  wsaTransparentSwapchain: 0
  m_HolographicPauseOnTrackingLoss: 1
  xboxOneDisableKinectGpuReservation: 1
  xboxOneEnable7thCore: 1
  vrSettings:
    enable360StereoCapture: 0
  isWsaHolographicRemotingEnabled: 0
  enableFrameTimingStats: 0
  enableOpenGLProfilerGPURecorders: 1
  useHDRDisplay: 0
  hdrBitDepth: 0
  m_ColorGamuts: 00000000
  targetPixelDensity: 30
  resolutionScalingMode: 0
  resetResolutionOnWindowResize: 0
  androidSupportedAspectRatio: 1
  androidMaxAspectRatio: 2.1
  applicationIdentifier:
    Standalone: com.AnnulusGames.BurstLinq
  buildNumber:
    Standalone: 0
    VisionOS: 0
    iPhone: 0
    tvOS: 0
  overrideDefaultApplicationIdentifier: 0
  AndroidBundleVersionCode: 1
  AndroidMinSdkVersion: 22
  AndroidTargetSdkVersion: 0
  AndroidPreferredInstallLocation: 1
  aotOptions: nimt-trampolines=1024
  stripEngineCode: 1
  iPhoneStrippingLevel: 0
  iPhoneScriptCallOptimization: 0
  ForceInternetPermission: 0
  ForceSDCardPermission: 0
  CreateWallpaper: 0
  APKExpansionFiles: 0
  keepLoadedShadersAlive: 0
  StripUnusedMeshComponents: 1
  strictShaderVariantMatching: 0
  VertexChannelCompressionMask: 4054
  iPhoneSdkVersion: 988
  iOSTargetOSVersionString: 12.0
  tvOSSdkVersion: 0
  tvOSRequireExtendedGameController: 0
  tvOSTargetOSVersionString: 12.0
  VisionOSSdkVersion: 0
  VisionOSTargetOSVersionString: 1.0
  uIPrerenderedIcon: 0
  uIRequiresPersistentWiFi: 0
  uIRequiresFullScreen: 1
  uIStatusBarHidden: 1
  uIExitOnSuspend: 0
  uIStatusBarStyle: 0
  appleTVSplashScreen: {fileID: 0}
  appleTVSplashScreen2x: {fileID: 0}
  tvOSSmallIconLayers: []
  tvOSSmallIconLayers2x: []
  tvOSLargeIconLayers: []
  tvOSLargeIconLayers2x: []
  tvOSTopShelfImageLayers: []
  tvOSTopShelfImageLayers2x: []
  tvOSTopShelfImageWideLayers: []
  tvOSTopShelfImageWideLayers2x: []
  iOSLaunchScreenType: 0
  iOSLaunchScreenPortrait: {fileID: 0}
  iOSLaunchScreenLandscape: {fileID: 0}
  iOSLaunchScreenBackgroundColor:
    serializedVersion: 2
    rgba: 0
  iOSLaunchScreenFillPct: 100
  iOSLaunchScreenSize: 100
  iOSLaunchScreenCustomXibPath: 
  iOSLaunchScreeniPadType: 0
  iOSLaunchScreeniPadImage: {fileID: 0}
  iOSLaunchScreeniPadBackgroundColor:
    serializedVersion: 2
    rgba: 0
  iOSLaunchScreeniPadFillPct: 100
  iOSLaunchScreeniPadSize: 100
  iOSLaunchScreeniPadCustomXibPath: 
  iOSLaunchScreenCustomStoryboardPath: 
  iOSLaunchScreeniPadCustomStoryboardPath: 
  iOSDeviceRequirements: []
  iOSURLSchemes: []
  macOSURLSchemes: []
  iOSBackgroundModes: 0
  iOSMetalForceHardShadows: 0
  metalEditorSupport: 1
  metalAPIValidation: 1
  iOSRenderExtraFrameOnPause: 0
  iosCopyPluginsCodeInsteadOfSymlink: 0
  appleDeveloperTeamID: 
  iOSManualSigningProvisioningProfileID: 
  tvOSManualSigningProvisioningProfileID: 
  VisionOSManualSigningProvisioningProfileID: 
  iOSManualSigningProvisioningProfileType: 0
  tvOSManualSigningProvisioningProfileType: 0
  VisionOSManualSigningProvisioningProfileType: 0
  appleEnableAutomaticSigning: 0
  iOSRequireARKit: 0
  iOSAutomaticallyDetectAndAddCapabilities: 1
  appleEnableProMotion: 0
  shaderPrecisionModel: 0
  clonedFromGUID: c0afd0d1d80e3634a9dac47e8a0426ea
  templatePackageId: com.unity.template.3d@8.1.1
  templateDefaultScene: Assets/Scenes/SampleScene.unity
  useCustomMainManifest: 0
  useCustomLauncherManifest: 0
  useCustomMainGradleTemplate: 0
  useCustomLauncherGradleManifest: 0
  useCustomBaseGradleTemplate: 0
  useCustomGradlePropertiesTemplate: 0
  useCustomGradleSettingsTemplate: 0
  useCustomProguardFile: 0
  AndroidTargetArchitectures: 1
  AndroidTargetDevices: 0
  AndroidSplashScreenScale: 0
  androidSplashScreen: {fileID: 0}
  AndroidKeystoreName: 
  AndroidKeyaliasName: 
  AndroidEnableArmv9SecurityFeatures: 0
  AndroidBuildApkPerCpuArchitecture: 0
  AndroidTVCompatibility: 0
  AndroidIsGame: 1
  AndroidEnableTango: 0
  androidEnableBanner: 1
  androidUseLowAccuracyLocation: 0
  androidUseCustomKeystore: 0
  m_AndroidBanners:
  - width: 320
    height: 180
    banner: {fileID: 0}
  androidGamepadSupportLevel: 0
  chromeosInputEmulation: 1
  AndroidMinifyRelease: 0
  AndroidMinifyDebug: 0
  AndroidValidateAppBundleSize: 1
  AndroidAppBundleSizeToValidate: 150
  m_BuildTargetIcons: []
  m_BuildTargetPlatformIcons:
  - m_BuildTarget: iPhone
    m_Icons:
    - m_Textures: []
      m_Width: 180
      m_Height: 180
      m_Kind: 0
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 120
      m_Height: 120
      m_Kind: 0
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 167
      m_Height: 167
      m_Kind: 0
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 152
      m_Height: 152
      m_Kind: 0
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 76
      m_Height: 76
      m_Kind: 0
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 120
      m_Height: 120
      m_Kind: 3
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 80
      m_Height: 80
      m_Kind: 3
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 80
      m_Height: 80
      m_Kind: 3
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 40
      m_Height: 40
      m_Kind: 3
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 87
      m_Height: 87
      m_Kind: 1
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 58
      m_Height: 58
      m_Kind: 1
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 29
      m_Height: 29
      m_Kind: 1
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 58
      m_Height: 58
      m_Kind: 1
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 29
      m_Height: 29
      m_Kind: 1
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 60
      m_Height: 60
      m_Kind: 2
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 40
      m_Height: 40
      m_Kind: 2
      m_SubKind: iPhone
    - m_Textures: []
      m_Width: 40
      m_Height: 40
      m_Kind: 2
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 20
      m_Height: 20
      m_Kind: 2
      m_SubKind: iPad
    - m_Textures: []
      m_Width: 1024
      m_Height: 1024
      m_Kind: 4
      m_SubKind: App Store
  - m_BuildTarget: Android
    m_Icons:
    - m_Textures: []
      m_Width: 432
      m_Height: 432
      m_Kind: 2
      m_SubKind: 
    - m_Textures: []
      m_Width: 324
      m_Height: 324
      m_Kind: 2
      m_SubKind: 
    - m_Textures: []
      m_Width: 216
      m_Height: 216
      m_Kind: 2
      m_SubKind: 
    - m_Textures: []
      m_Width: 162
      m_Height: 162
      m_Kind: 2
      m_SubKind: 
    - m_Textures: []
      m_Width: 108
      m_Height: 108
      m_Kind: 2
      m_SubKind: 
    - m_Textures: []
      m_Width: 81
      m_Height: 81
      m_Kind: 2
      m_SubKind: 
    - m_Textures: []
      m_Width: 192
      m_Height: 192
      m_Kind: 1
      m_SubKind: 
    - m_Textures: []
      m_Width: 144
      m_Height: 144
      m_Kind: 1
      m_SubKind: 
    - m_Textures: []
      m_Width: 96
      m_Height: 96
      m_Kind: 1
      m_SubKind: 
    - m_Textures: []
      m_Width: 72
      m_Height: 72
      m_Kind: 1
      m_SubKind: 
    - m_Textures: []
      m_Width: 48
      m_Height: 48
      m_Kind: 1
      m_SubKind: 
    - m_Textures: []
      m_Width: 36
      m_Height: 36
      m_Kind: 1
      m_SubKind: 
    - m_Textures: []
      m_Width: 192
      m_Height: 192
      m_Kind: 0
      m_SubKind: 
    - m_Textures: []
      m_Width: 144
      m_Height: 144
      m_Kind: 0
      m_SubKind: 
    - m_Textures: []
      m_Width: 96
      m_Height: 96
      m_Kind: 0
      m_SubKind: 
    - m_Textures: []
      m_Width: 72
      m_Height: 72
      m_Kind: 0
      m_SubKind: 
    - m_Textures: []
      m_Width: 48
      m_Height: 48
      m_Kind: 0
      m_SubKind: 
    - m_Textures: []
      m_Width: 36
      m_Height: 36
      m_Kind: 0
      m_SubKind: 
  m_BuildTargetBatching:
  - m_BuildTarget: Standalone
    m_StaticBatching: 1
    m_DynamicBatching: 0
  - m_BuildTarget: tvOS
    m_StaticBatching: 1
    m_DynamicBatching: 0
  - m_BuildTarget: Android
    m_StaticBatching: 1
    m_DynamicBatching: 0
  - m_BuildTarget: iPhone
    m_StaticBatching: 1
    m_DynamicBatching: 0
  - m_BuildTarget: WebGL
    m_StaticBatching: 0
    m_DynamicBatching: 0
  m_BuildTargetShaderSettings: []
  m_BuildTargetGraphicsJobs:
  - m_BuildTarget: MacStandaloneSupport
    m_GraphicsJobs: 0
  - m_BuildTarget: Switch
    m_GraphicsJobs: 1
  - m_BuildTarget: MetroSupport
    m_GraphicsJobs: 1
  - m_BuildTarget: AppleTVSupport
    m_GraphicsJobs: 0
  - m_BuildTarget: BJMSupport
    m_GraphicsJobs: 1
  - m_BuildTarget: LinuxStandaloneSupport
    m_GraphicsJobs: 1
  - m_BuildTarget: PS4Player
    m_GraphicsJobs: 1
  - m_BuildTarget: iOSSupport
    m_GraphicsJobs: 0
  - m_BuildTarget: WindowsStandaloneSupport
    m_GraphicsJobs: 1
  - m_BuildTarget: XboxOnePlayer
    m_GraphicsJobs: 1
  - m_BuildTarget: LuminSupport
    m_GraphicsJobs: 0
  - m_BuildTarget: AndroidPlayer
    m_GraphicsJobs: 0
  - m_BuildTarget: WebGLSupport
    m_GraphicsJobs: 0
  m_BuildTargetGraphicsJobMode:
  - m_BuildTarget: PS4Player
    m_GraphicsJobMode: 0
  - m_BuildTarget: XboxOnePlayer
    m_GraphicsJobMode: 0
  m_BuildTargetGraphicsAPIs:
  - m_BuildTarget: AndroidPlayer
    m_APIs: 150000000b000000
    m_Automatic: 1
  - m_BuildTarget: iOSSupport
    m_APIs: 10000000
    m_Automatic: 1
  - m_BuildTarget: AppleTVSupport
    m_APIs: 10000000
    m_Automatic: 1
  - m_BuildTarget: WebGLSupport
    m_APIs: 0b000000
    m_Automatic: 1
  m_BuildTargetVRSettings:
  - m_BuildTarget: Standalone
    m_Enabled: 0
    m_Devices:
    - Oculus
    - OpenVR
  m_DefaultShaderChunkSizeInMB: 16
  m_DefaultShaderChunkCount: 0
  openGLRequireES31: 0
  openGLRequireES31AEP: 0
  openGLRequireES32: 0
  m_TemplateCustomTags: {}
  mobileMTRendering:
    Android: 1
    iPhone: 1
    tvOS: 1
  m_BuildTargetGroupLightmapEncodingQuality:
  - m_BuildTarget: Android
    m_EncodingQuality: 1
  - m_BuildTarget: iPhone
    m_EncodingQuality: 1
  - m_BuildTarget: tvOS
    m_EncodingQuality: 1
  m_BuildTargetGroupHDRCubemapEncodingQuality:
  - m_BuildTarget: Android
    m_EncodingQuality: 1
  - m_BuildTarget: iPhone
    m_EncodingQuality: 1
  - m_BuildTarget: tvOS
    m_EncodingQuality: 1
  m_BuildTargetGroupLightmapSettings: []
  m_BuildTargetGroupLoadStoreDebugModeSettings: []
  m_BuildTargetNormalMapEncoding:
  - m_BuildTarget: Android
    m_Encoding: 1
  - m_BuildTarget: iPhone
    m_Encoding: 1
  - m_BuildTarget: tvOS
    m_Encoding: 1
  m_BuildTargetDefaultTextureCompressionFormat:
  - m_BuildTarget: Android
    m_Format: 3
  playModeTestRunnerEnabled: 0
  runPlayModeTestAsEditModeTest: 0
  actionOnDotNetUnhandledException: 1
  enableInternalProfiler: 0
  logObjCUncaughtExceptions: 1
  enableCrashReportAPI: 0
  cameraUsageDescription: 
  locationUsageDescription: 
  microphoneUsageDescription: 
  bluetoothUsageDescription: 
  macOSTargetOSVersion: 10.13.0
  switchNMETAOverride: 
  switchNetLibKey: 
  switchSocketMemoryPoolSize: 6144
  switchSocketAllocatorPoolSize: 128
  switchSocketConcurrencyLimit: 14
  switchScreenResolutionBehavior: 2
  switchUseCPUProfiler: 0
  switchUseGOLDLinker: 0
  switchLTOSetting: 0
  switchApplicationID: 0x01004b9000490000
  switchNSODependencies: 
  switchCompilerFlags: 
  switchTitleNames_0: 
  switchTitleNames_1: 
  switchTitleNames_2: 
  switchTitleNames_3: 
  switchTitleNames_4: 
  switchTitleNames_5: 
  switchTitleNames_6: 
  switchTitleNames_7: 
  switchTitleNames_8: 
  switchTitleNames_9: 
  switchTitleNames_10: 
  switchTitleNames_11: 
  switchTitleNames_12: 
  switchTitleNames_13: 
  switchTitleNames_14: 
  switchTitleNames_15: 
  switchPublisherNames_0: 
  switchPublisherNames_1: 
  switchPublisherNames_2: 
  switchPublisherNames_3: 
  switchPublisherNames_4: 
  switchPublisherNames_5: 
  switchPublisherNames_6: 
  switchPublisherNames_7: 
  switchPublisherNames_8: 
  switchPublisherNames_9: 
  switchPublisherNames_10: 
  switchPublisherNames_11: 
  switchPublisherNames_12: 
  switchPublisherNames_13: 
  switchPublisherNames_14: 
  switchPublisherNames_15: 
  switchIcons_0: {fileID: 0}
  switchIcons_1: {fileID: 0}
  switchIcons_2: {fileID: 0}
  switchIcons_3: {fileID: 0}
  switchIcons_4: {fileID: 0}
  switchIcons_5: {fileID: 0}
  switchIcons_6: {fileID: 0}
  switchIcons_7: {fileID: 0}
  switchIcons_8: {fileID: 0}
  switchIcons_9: {fileID: 0}
  switchIcons_10: {fileID: 0}
  switchIcons_11: {fileID: 0}
  switchIcons_12: {fileID: 0}
  switchIcons_13: {fileID: 0}
  switchIcons_14: {fileID: 0}
  switchIcons_15: {fileID: 0}
  switchSmallIcons_0: {fileID: 0}
  switchSmallIcons_1: {fileID: 0}
  switchSmallIcons_2: {fileID: 0}
  switchSmallIcons_3: {fileID: 0}
  switchSmallIcons_4: {fileID: 0}
  switchSmallIcons_5: {fileID: 0}
  switchSmallIcons_6: {fileID: 0}
  switchSmallIcons_7: {fileID: 0}
  switchSmallIcons_8: {fileID: 0}
  switchSmallIcons_9: {fileID: 0}
  switchSmallIcons_10: {fileID: 0}
  switchSmallIcons_11: {fileID: 0}
  switchSmallIcons_12: {fileID: 0}
  switchSmallIcons_13: {fileID: 0}
  switchSmallIcons_14: {fileID: 0}
  switchSmallIcons_15: {fileID: 0}
  switchManualHTML: 
  switchAccessibleURLs: 
  switchLegalInformation: 
  switchMainThreadStackSize: 1048576
  switchPresenceGroupId: 
  switchLogoHandling: 0
  switchReleaseVersion: 0
  switchDisplayVersion: 1.0.0
  switchStartupUserAccount: 0
  switchSupportedLanguagesMask: 0
  switchLogoType: 0
  switchApplicationErrorCodeCategory: 
  switchUserAccountSaveDataSize: 0
  switchUserAccountSaveDataJournalSize: 0
  switchApplicationAttribute: 0
  switchCardSpecSize: -1
  switchCardSpecClock: -1
  switchRatingsMask: 0
  switchRatingsInt_0: 0
  switchRatingsInt_1: 0
  switchRatingsInt_2: 0
  switchRatingsInt_3: 0
  switchRatingsInt_4: 0
  switchRatingsInt_5: 0
  switchRatingsInt_6: 0
  switchRatingsInt_7: 0
  switchRatingsInt_8: 0
  switchRatingsInt_9: 0
  switchRatingsInt_10: 0
  switchRatingsInt_11: 0
  switchRatingsInt_12: 0
  switchLocalCommunicationIds_0: 
  switchLocalCommunicationIds_1: 
  switchLocalCommunicationIds_2: 
  switchLocalCommunicationIds_3: 
  switchLocalCommunicationIds_4: 
  switchLocalCommunicationIds_5: 
  switchLocalCommunicationIds_6: 
  switchLocalCommunicationIds_7: 
  switchParentalControl: 0
  switchAllowsScreenshot: 1
  switchAllowsVideoCapturing: 1
  switchAllowsRuntimeAddOnContentInstall: 0
  switchDataLossConfirmation: 0
  switchUserAccountLockEnabled: 0
  switchSystemResourceMemory: 16777216
  switchSupportedNpadStyles: 22
  switchNativeFsCacheSize: 32
  switchIsHoldTypeHorizontal: 0
  switchSupportedNpadCount: 8
  switchEnableTouchScreen: 1
  switchSocketConfigEnabled: 0
  switchTcpInitialSendBufferSize: 32
  switchTcpInitialReceiveBufferSize: 64
  switchTcpAutoSendBufferSizeMax: 256
  switchTcpAutoReceiveBufferSizeMax: 256
  switchUdpSendBufferSize: 9
  switchUdpReceiveBufferSize: 42
  switchSocketBufferEfficiency: 4
  switchSocketInitializeEnabled: 1
  switchNetworkInterfaceManagerInitializeEnabled: 1
  switchPlayerConnectionEnabled: 1
  switchUseNewStyleFilepaths: 1
  switchUseLegacyFmodPriorities: 0
  switchUseMicroSleepForYield: 1
  switchEnableRamDiskSupport: 0
  switchMicroSleepForYieldTime: 25
  switchRamDiskSpaceSize: 12
  ps4NPAgeRating: 12
  ps4NPTitleSecret: 
  ps4NPTrophyPackPath: 
  ps4ParentalLevel: 11
  ps4ContentID: ED1633-NPXX51362_00-0000000000000000
  ps4Category: 0
  ps4MasterVersion: 01.00
  ps4AppVersion: 01.00
  ps4AppType: 0
  ps4ParamSfxPath: 
  ps4VideoOutPixelFormat: 0
  ps4VideoOutInitialWidth: 1920
  ps4VideoOutBaseModeInitialWidth: 1920
  ps4VideoOutReprojectionRate: 60
  ps4PronunciationXMLPath: 
  ps4PronunciationSIGPath: 
  ps4BackgroundImagePath: 
  ps4StartupImagePath: 
  ps4StartupImagesFolder: 
  ps4IconImagesFolder: 
  ps4SaveDataImagePath: 
  ps4SdkOverride: 
  ps4BGMPath: 
  ps4ShareFilePath: 
  ps4ShareOverlayImagePath: 
  ps4PrivacyGuardImagePath: 
  ps4ExtraSceSysFile: 
  ps4NPtitleDatPath: 
  ps4RemotePlayKeyAssignment: -1
  ps4RemotePlayKeyMappingDir: 
  ps4PlayTogetherPlayerCount: 0
  ps4EnterButtonAssignment: 1
  ps4ApplicationParam1: 0
  ps4ApplicationParam2: 0
  ps4ApplicationParam3: 0
  ps4ApplicationParam4: 0
  ps4DownloadDataSize: 0
  ps4GarlicHeapSize: 2048
  ps4ProGarlicHeapSize: 2560
  playerPrefsMaxSize: 32768
  ps4Passcode: frAQBc8Wsa1xVPfvJcrgRYwTiizs2trQ
  ps4pnSessions: 1
  ps4pnPresence: 1
  ps4pnFriends: 1
  ps4pnGameCustomData: 1
  playerPrefsSupport: 0
  enableApplicationExit: 0
  resetTempFolder: 1
  restrictedAudioUsageRights: 0
  ps4UseResolutionFallback: 0
  ps4ReprojectionSupport: 0
  ps4UseAudio3dBackend: 0
  ps4UseLowGarlicFragmentationMode: 1
  ps4SocialScreenEnabled: 0
  ps4ScriptOptimizationLevel: 0
  ps4Audio3dVirtualSpeakerCount: 14
  ps4attribCpuUsage: 0
  ps4PatchPkgPath: 
  ps4PatchLatestPkgPath: 
  ps4PatchChangeinfoPath: 
  ps4PatchDayOne: 0
  ps4attribUserManagement: 0
  ps4attribMoveSupport: 0
  ps4attrib3DSupport: 0
  ps4attribShareSupport: 0
  ps4attribExclusiveVR: 0
  ps4disableAutoHideSplash: 0
  ps4videoRecordingFeaturesUsed: 0
  ps4contentSearchFeaturesUsed: 0
  ps4CompatibilityPS5: 0
  ps4AllowPS5Detection: 0
  ps4GPU800MHz: 1
  ps4attribEyeToEyeDistanceSettingVR: 0
  ps4IncludedModules: []
  ps4attribVROutputEnabled: 0
  monoEnv: 
  splashScreenBackgroundSourceLandscape: {fileID: 0}
  splashScreenBackgroundSourcePortrait: {fileID: 0}
  blurSplashScreenBackground: 1
  spritePackerPolicy: 
  webGLMemorySize: 16
  webGLExceptionSupport: 1
  webGLNameFilesAsHashes: 0
  webGLShowDiagnostics: 0
  webGLDataCaching: 1
  webGLDebugSymbols: 0
  webGLEmscriptenArgs: 
  webGLModulesDirectory: 
  webGLTemplate: APPLICATION:Default
  webGLAnalyzeBuildSize: 0
  webGLUseEmbeddedResources: 0
  webGLCompressionFormat: 1
  webGLWasmArithmeticExceptions: 0
  webGLLinkerTarget: 1
  webGLThreadsSupport: 0
  webGLDecompressionFallback: 0
  webGLInitialMemorySize: 32
  webGLMaximumMemorySize: 2048
  webGLMemoryGrowthMode: 2
  webGLMemoryLinearGrowthStep: 16
  webGLMemoryGeometricGrowthStep: 0.2
  webGLMemoryGeometricGrowthCap: 96
  webGLPowerPreference: 2
  scriptingDefineSymbols:
    Standalone: UNITY_BURST_EXPERIMENTAL_LOOP_INTRINSICS
  additionalCompilerArguments: {}
  platformArchitecture: {}
  scriptingBackend:
    Standalone: 1
  il2cppCompilerConfiguration: {}
  il2cppCodeGeneration: {}
  managedStrippingLevel:
    EmbeddedLinux: 1
    GameCoreScarlett: 1
    GameCoreXboxOne: 1
    Nintendo Switch: 1
    PS4: 1
    PS5: 1
    QNX: 1
    Stadia: 1
    VisionOS: 1
    WebGL: 1
    Windows Store Apps: 1
    XboxOne: 1
    iPhone: 1
    tvOS: 1
  incrementalIl2cppBuild: {}
  suppressCommonWarnings: 1
  allowUnsafeCode: 0
  useDeterministicCompilation: 1
  additionalIl2CppArgs: 
  scriptingRuntimeVersion: 1
  gcIncremental: 1
  gcWBarrierValidation: 0
  apiCompatibilityLevelPerPlatform: {}
  m_RenderingPath: 1
  m_MobileRenderingPath: 1
  metroPackageName: LinqJob
  metroPackageVersion: 
  metroCertificatePath: 
  metroCertificatePassword: 
  metroCertificateSubject: 
  metroCertificateIssuer: 
  metroCertificateNotAfter: 0000000000000000
  metroApplicationDescription: LinqJob
  wsaImages: {}
  metroTileShortName: 
  metroTileShowName: 0
  metroMediumTileShowName: 0
  metroLargeTileShowName: 0
  metroWideTileShowName: 0
  metroSupportStreamingInstall: 0
  metroLastRequiredScene: 0
  metroDefaultTileSize: 1
  metroTileForegroundText: 2
  metroTileBackgroundColor: {r: 0.13333334, g: 0.17254902, b: 0.21568628, a: 0}
  metroSplashScreenBackgroundColor: {r: 0.12941177, g: 0.17254902, b: 0.21568628, a: 1}
  metroSplashScreenUseBackgroundColor: 0
  platformCapabilities: {}
  metroTargetDeviceFamilies: {}
  metroFTAName: 
  metroFTAFileTypes: []
  metroProtocolName: 
  vcxProjDefaultLanguage: 
  XboxOneProductId: 
  XboxOneUpdateKey: 
  XboxOneSandboxId: 
  XboxOneContentId: 
  XboxOneTitleId: 
  XboxOneSCId: 
  XboxOneGameOsOverridePath: 
  XboxOnePackagingOverridePath: 
  XboxOneAppManifestOverridePath: 
  XboxOneVersion: 1.0.0.0
  XboxOnePackageEncryption: 0
  XboxOnePackageUpdateGranularity: 2
  XboxOneDescription: 
  XboxOneLanguage:
  - enus
  XboxOneCapability: []
  XboxOneGameRating: {}
  XboxOneIsContentPackage: 0
  XboxOneEnhancedXboxCompatibilityMode: 0
  XboxOneEnableGPUVariability: 1
  XboxOneSockets: {}
  XboxOneSplashScreen: {fileID: 0}
  XboxOneAllowedProductIds: []
  XboxOnePersistentLocalStorageSize: 0
  XboxOneXTitleMemory: 8
  XboxOneOverrideIdentityName: 
  XboxOneOverrideIdentityPublisher: 
  vrEditorSettings: {}
  cloudServicesEnabled:
    UNet: 1
  luminIcon:
    m_Name: 
    m_ModelFolderPath: 
    m_PortalFolderPath: 
  luminCert:
    m_CertPath: 
    m_SignPackage: 1
  luminIsChannelApp: 0
  luminVersion:
    m_VersionCode: 1
    m_VersionName: 
  hmiPlayerDataPath: 
  hmiForceSRGBBlit: 1
  embeddedLinuxEnableGamepadInput: 1
  hmiLogStartupTiming: 0
  hmiCpuConfiguration: 
  apiCompatibilityLevel: 6
  activeInputHandler: 0
  windowsGamepadBackendHint: 0
  cloudProjectId: 
  framebufferDepthMemorylessMode: 0
  qualitySettingsNames: []
  projectName: 
  organizationId: 
  cloudEnabled: 0
  legacyClampBlendShapeWeights: 0
  hmiLoadingImage: {fileID: 0}
  platformRequiresReadableAssets: 0
  virtualTexturingSupportEnabled: 0
  insecureHttpOption: 0


================================================
FILE: ProjectSettings/ProjectVersion.txt
================================================
m_EditorVersion: 2022.3.7f1
m_EditorVersionWithRevision: 2022.3.7f1 (b16b3b16c7a0)


================================================
FILE: ProjectSettings/QualitySettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!47 &1
QualitySettings:
  m_ObjectHideFlags: 0
  serializedVersion: 5
  m_CurrentQuality: 5
  m_QualitySettings:
  - serializedVersion: 2
    name: Very Low
    pixelLightCount: 0
    shadows: 0
    shadowResolution: 0
    shadowProjection: 1
    shadowCascades: 1
    shadowDistance: 15
    shadowNearPlaneOffset: 3
    shadowCascade2Split: 0.33333334
    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
    shadowmaskMode: 0
    blendWeights: 1
    textureQuality: 1
    anisotropicTextures: 0
    antiAliasing: 0
    softParticles: 0
    softVegetation: 0
    realtimeReflectionProbes: 0
    billboardsFaceCameraPosition: 0
    vSyncCount: 0
    lodBias: 0.3
    maximumLODLevel: 0
    streamingMipmapsActive: 0
    streamingMipmapsAddAllCameras: 1
    streamingMipmapsMemoryBudget: 512
    streamingMipmapsRenderersPerFrame: 512
    streamingMipmapsMaxLevelReduction: 2
    streamingMipmapsMaxFileIORequests: 1024
    particleRaycastBudget: 4
    asyncUploadTimeSlice: 2
    asyncUploadBufferSize: 16
    asyncUploadPersistentBuffer: 1
    resolutionScalingFixedDPIFactor: 1
    excludedTargetPlatforms: []
  - serializedVersion: 2
    name: Low
    pixelLightCount: 0
    shadows: 0
    shadowResolution: 0
    shadowProjection: 1
    shadowCascades: 1
    shadowDistance: 20
    shadowNearPlaneOffset: 3
    shadowCascade2Split: 0.33333334
    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
    shadowmaskMode: 0
    blendWeights: 2
    textureQuality: 0
    anisotropicTextures: 0
    antiAliasing: 0
    softParticles: 0
    softVegetation: 0
    realtimeReflectionProbes: 0
    billboardsFaceCameraPosition: 0
    vSyncCount: 0
    lodBias: 0.4
    maximumLODLevel: 0
    streamingMipmapsActive: 0
    streamingMipmapsAddAllCameras: 1
    streamingMipmapsMemoryBudget: 512
    streamingMipmapsRenderersPerFrame: 512
    streamingMipmapsMaxLevelReduction: 2
    streamingMipmapsMaxFileIORequests: 1024
    particleRaycastBudget: 16
    asyncUploadTimeSlice: 2
    asyncUploadBufferSize: 16
    asyncUploadPersistentBuffer: 1
    resolutionScalingFixedDPIFactor: 1
    excludedTargetPlatforms: []
  - serializedVersion: 2
    name: Medium
    pixelLightCount: 1
    shadows: 1
    shadowResolution: 0
    shadowProjection: 1
    shadowCascades: 1
    shadowDistance: 20
    shadowNearPlaneOffset: 3
    shadowCascade2Split: 0.33333334
    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
    shadowmaskMode: 0
    blendWeights: 2
    textureQuality: 0
    anisotropicTextures: 1
    antiAliasing: 0
    softParticles: 0
    softVegetation: 0
    realtimeReflectionProbes: 0
    billboardsFaceCameraPosition: 0
    vSyncCount: 1
    lodBias: 0.7
    maximumLODLevel: 0
    streamingMipmapsActive: 0
    streamingMipmapsAddAllCameras: 1
    streamingMipmapsMemoryBudget: 512
    streamingMipmapsRenderersPerFrame: 512
    streamingMipmapsMaxLevelReduction: 2
    streamingMipmapsMaxFileIORequests: 1024
    particleRaycastBudget: 64
    asyncUploadTimeSlice: 2
    asyncUploadBufferSize: 16
    asyncUploadPersistentBuffer: 1
    resolutionScalingFixedDPIFactor: 1
    excludedTargetPlatforms: []
  - serializedVersion: 2
    name: High
    pixelLightCount: 2
    shadows: 2
    shadowResolution: 1
    shadowProjection: 1
    shadowCascades: 2
    shadowDistance: 40
    shadowNearPlaneOffset: 3
    shadowCascade2Split: 0.33333334
    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
    shadowmaskMode: 1
    blendWeights: 2
    textureQuality: 0
    anisotropicTextures: 1
    antiAliasing: 0
    softParticles: 0
    softVegetation: 1
    realtimeReflectionProbes: 1
    billboardsFaceCameraPosition: 1
    vSyncCount: 1
    lodBias: 1
    maximumLODLevel: 0
    streamingMipmapsActive: 0
    streamingMipmapsAddAllCameras: 1
    streamingMipmapsMemoryBudget: 512
    streamingMipmapsRenderersPerFrame: 512
    streamingMipmapsMaxLevelReduction: 2
    streamingMipmapsMaxFileIORequests: 1024
    particleRaycastBudget: 256
    asyncUploadTimeSlice: 2
    asyncUploadBufferSize: 16
    asyncUploadPersistentBuffer: 1
    resolutionScalingFixedDPIFactor: 1
    excludedTargetPlatforms: []
  - serializedVersion: 2
    name: Very High
    pixelLightCount: 3
    shadows: 2
    shadowResolution: 2
    shadowProjection: 1
    shadowCascades: 2
    shadowDistance: 70
    shadowNearPlaneOffset: 3
    shadowCascade2Split: 0.33333334
    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
    shadowmaskMode: 1
    blendWeights: 4
    textureQuality: 0
    anisotropicTextures: 2
    antiAliasing: 2
    softParticles: 1
    softVegetation: 1
    realtimeReflectionProbes: 1
    billboardsFaceCameraPosition: 1
    vSyncCount: 1
    lodBias: 1.5
    maximumLODLevel: 0
    streamingMipmapsActive: 0
    streamingMipmapsAddAllCameras: 1
    streamingMipmapsMemoryBudget: 512
    streamingMipmapsRenderersPerFrame: 512
    streamingMipmapsMaxLevelReduction: 2
    streamingMipmapsMaxFileIORequests: 1024
    particleRaycastBudget: 1024
    asyncUploadTimeSlice: 2
    asyncUploadBufferSize: 16
    asyncUploadPersistentBuffer: 1
    resolutionScalingFixedDPIFactor: 1
    excludedTargetPlatforms: []
  - serializedVersion: 2
    name: Ultra
    pixelLightCount: 4
    shadows: 2
    shadowResolution: 2
    shadowProjection: 1
    shadowCascades: 4
    shadowDistance: 150
    shadowNearPlaneOffset: 3
    shadowCascade2Split: 0.33333334
    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
    shadowmaskMode: 1
    blendWeights: 4
    textureQuality: 0
    anisotropicTextures: 2
    antiAliasing: 2
    softParticles: 1
    softVegetation: 1
    realtimeReflectionProbes: 1
    billboardsFaceCameraPosition: 1
    vSyncCount: 1
    lodBias: 2
    maximumLODLevel: 0
    streamingMipmapsActive: 0
    streamingMipmapsAddAllCameras: 1
    streamingMipmapsMemoryBudget: 512
    streamingMipmapsRenderersPerFrame: 512
    streamingMipmapsMaxLevelReduction: 2
    streamingMipmapsMaxFileIORequests: 1024
    particleRaycastBudget: 4096
    asyncUploadTimeSlice: 2
    asyncUploadBufferSize: 16
    asyncUploadPersistentBuffer: 1
    resolutionScalingFixedDPIFactor: 1
    excludedTargetPlatforms: []
  m_PerPlatformDefaultQuality:
    Android: 2
    Lumin: 5
    Nintendo 3DS: 5
    Nintendo Switch: 5
    PS4: 5
    PSP2: 2
    Stadia: 5
    Standalone: 5
    WebGL: 3
    Windows Store Apps: 5
    XboxOne: 5
    iPhone: 2
    tvOS: 2


================================================
FILE: ProjectSettings/SceneTemplateSettings.json
================================================
{
    "templatePinStates": [],
    "dependencyTypeInfos": [
        {
            "userAdded": false,
            "type": "UnityEngine.AnimationClip",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEditor.Animations.AnimatorController",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.AnimatorOverrideController",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEditor.Audio.AudioMixerController",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.ComputeShader",
            "defaultInstantiationMode": 1
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Cubemap",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.GameObject",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEditor.LightingDataAsset",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.LightingSettings",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Material",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEditor.MonoScript",
            "defaultInstantiationMode": 1
        },
        {
            "userAdded": false,
            "type": "UnityEngine.PhysicMaterial",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.PhysicsMaterial2D",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Rendering.PostProcessing.PostProcessProfile",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Rendering.PostProcessing.PostProcessResources",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Rendering.VolumeProfile",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEditor.SceneAsset",
            "defaultInstantiationMode": 1
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Shader",
            "defaultInstantiationMode": 1
        },
        {
            "userAdded": false,
            "type": "UnityEngine.ShaderVariantCollection",
            "defaultInstantiationMode": 1
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Texture",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Texture2D",
            "defaultInstantiationMode": 0
        },
        {
            "userAdded": false,
            "type": "UnityEngine.Timeline.TimelineAsset",
            "defaultInstantiationMode": 0
        }
    ],
    "defaultDependencyTypeInfo": {
        "userAdded": false,
        "type": "<default_scene_template_dependencies>",
        "defaultInstantiationMode": 1
    },
    "newSceneOverride": 0
}

================================================
FILE: ProjectSettings/TagManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!78 &1
TagManager:
  serializedVersion: 2
  tags: []
  layers:
  - Default
  - TransparentFX
  - Ignore Raycast
  - 
  - Water
  - UI
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  - 
  m_SortingLayers:
  - name: Default
    uniqueID: 0
    locked: 0


================================================
FILE: ProjectSettings/TimeManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!5 &1
TimeManager:
  m_ObjectHideFlags: 0
  Fixed Timestep: 0.02
  Maximum Allowed Timestep: 0.33333334
  m_TimeScale: 1
  Maximum Particle Timestep: 0.03


================================================
FILE: ProjectSettings/UnityConnectSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!310 &1
UnityConnectSettings:
  m_ObjectHideFlags: 0
  serializedVersion: 1
  m_Enabled: 0
  m_TestMode: 0
  m_EventOldUrl: https://api.uca.cloud.unity3d.com/v1/events
  m_EventUrl: https://cdp.cloud.unity3d.com/v1/events
  m_ConfigUrl: https://config.uca.cloud.unity3d.com
  m_DashboardUrl: https://dashboard.unity3d.com
  m_TestInitMode: 0
  CrashReportingSettings:
    m_EventUrl: https://perf-events.cloud.unity3d.com
    m_Enabled: 0
    m_LogBufferSize: 10
    m_CaptureEditorExceptions: 1
  UnityPurchasingSettings:
    m_Enabled: 0
    m_TestMode: 0
  UnityAnalyticsSettings:
    m_Enabled: 0
    m_TestMode: 0
    m_InitializeOnStartup: 1
    m_PackageRequiringCoreStatsPresent: 0
  UnityAdsSettings:
    m_Enabled: 0
    m_InitializeOnStartup: 1
    m_TestMode: 0
    m_IosGameId: 
    m_AndroidGameId: 
    m_GameIds: {}
    m_GameId: 
  PerformanceReportingSettings:
    m_Enabled: 0


================================================
FILE: ProjectSettings/VFXManager.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!937362698 &1
VFXManager:
  m_ObjectHideFlags: 0
  m_IndirectShader: {fileID: 0}
  m_CopyBufferShader: {fileID: 0}
  m_SortShader: {fileID: 0}
  m_StripUpdateShader: {fileID: 0}
  m_RenderPipeSettingsPath: 
  m_FixedTimeStep: 0.016666668
  m_MaxDeltaTime: 0.05


================================================
FILE: ProjectSettings/VersionControlSettings.asset
================================================
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!890905787 &1
VersionControlSettings:
  m_ObjectHideFlags: 0
  m_Mode: Visible Meta Files
  m_CollabEditorSettings:
    inProgressEnabled: 1


================================================
FILE: ProjectSettings/XRSettings.asset
================================================
{
    "m_SettingKeys": [
        "VR Device Disabled",
        "VR Device User Alert"
    ],
    "m_SettingValues": [
        "False",
        "False"
    ]
}

================================================
FILE: README.md
================================================
# BurstLinq
Extremely fast LINQ aggregation operations implementation optimized by Burst Compiler

<img src="https://github.com/AnnulusGames/BurstLinq/blob/main/Assets/BurstLinq/Documentation~/img1.png" width="800">

[![license](https://img.shields.io/badge/LICENSE-MIT-green.svg)](LICENSE)

[日本語版READMEはこちら](README_JA.md)

## Overview

BurstLinq is a library designed to accelerate LINQ aggregation operations (`Sum`, `Average`, `Min`, etc.) using Unity's Burst Compiler. By integrating BurstLinq, automatically optimized implementations are applied to LINQ methods eligible for Burst, resulting in significantly higher performance compared to regular LINQ.

Additionally, BurstLinq adds operators like `Sum`, `Min`, etc., to collection types that LINQ cannot usually operate on, such as `NativeArray<T>` or `Span<T>`. It also supports operations like `Sum` and `Average` for Unity-specific types such as `Vector3` and `float3`.

> The concept of BurstLinq is inspired by [Cysharp/SimdLinq](https://github.com/Cysharp/SimdLinq). BurstLinq is a Unity-optimized version that uses Burst instead of .NET's SIMD API.

## Setup

### Requirements

* Unity 2021.3 or later
* Burst 1.6.0 or later

### Installation

1. Open the Package Manager by going to Window > Package Manager.
2. Click on the "+" button and select "Add package from git URL".
3. Enter the following URL:

```
https://github.com/AnnulusGames/BurstLinq.git?path=/Assets/BurstLinq
```

Alternatively, open `Packages/manifest.json` and add the following to the `dependencies` block:

```json
{
    "dependencies": {
        "com.annulusgames.burst-linq": "https://github.com/AnnulusGames/BurstLinq.git?path=/Assets/BurstLinq"
    }
}
```

## Quick Start

BurstLinq is designed as a 'Drop-in replacement' similar to SimdLinq, simply including `using BurstLinq;` will automatically apply BurstLinq methods to all operators eligible for Burst.

```cs
using System.Collections.Generic;
using System.Linq;
using BurstLinq;

var enumerable = Enumerable.Range(0, 100);
var array = enumerable.ToArray();

// Enumerable.Sum()
var linqSum = enumerable.Sum();

// BurstLinqExtensions.Sum()
var burstLinqSum = array.Sum();
```

## Supported Types and Operators

Below is the list of operators and types supported by BurstLinq.

### Supported Collection Types

* `T[]`
* `List<T>`
* `Memory<T>`
* `ReadOnlyMemory<T>`
* `Span<T>`
* `ReadOnlySpan<T>`
* `NativeArray<T>`
* `NativeList<T>`
* `NativeSlice<T>`

### Supported Operators

* Sum (`int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)
* Average (`int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)
* Min (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`)
* Max (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`)
* Contains (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)
* SequenceEqual (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)

## Compatibility with LINQ

BurstLinq may behave differently compared to LINQ as it prioritizes high performance. Be mindful of the following differences when using it.

### Sum/Average

While LINQ's Sum is `checked`, BurstLinq is `unchecked`. Burst does not support overflow detection, hence it is set to `unchecked` to avoid behavioral differences when Burst is disabled.

### Handling of Floating-Point Types

BurstLinq's `Sum` specifies `[BurstCompile(FloatMode = FloatMode.Fast)]`, resulting in slight computational discrepancies compared to regular LINQ's `Sum`. While this is rarely an issue, note the lack of compatibility.

Additionally, BurstLinq does not check for NaN for float/double types, so please take note of this aspect.

## License

[MIT License](LICENSE)

================================================
FILE: README_JA.md
================================================
# BurstLinq
 Extremely fast LINQ aggregation operations implementation optimized by Burst Compiler

<img src="https://github.com/AnnulusGames/BurstLinq/blob/main/Assets/BurstLinq/Documentation~/img1.png" width="800">

[![license](https://img.shields.io/badge/LICENSE-MIT-green.svg)](LICENSE)

[English README is here](README.md)

## 概要

BurstLinqはUnityのBurst Compilerを用いてLINQの集約操作(`Sum`、`Average`、`Min`, etc..)を高速化するライブラリです。BurstLinqを導入することで、Burstが適用可能なLINQメソッドに対して自動的に最適化された実装が適用されるようになり、通常のLINQと比較して遥かに高いパフォーマンスを実現します。

また、`NativeArray<T>`や`Span<T>`など本来LINQが使用できないコレクション型に対して`Sum`、`Min`などのオペレータを追加するほか、`Vector3`、`float3`などのUnity独自の型に対する`Sum`、`Average`もサポートします。

> BurstLinqのコンセプトは[Cysharp/SimdLinq](https://github.com/Cysharp/SimdLinq)にインスパイアされており、こちらは.NETのSIMD APIの代わりにBurstを利用した、Unityに最適化された実装になっています。

## セットアップ

### 要件

* Unity 2021.3 以上
* Burst 1.6.0 以上

### インストール

1. Window > Package ManagerからPackage Managerを開く
2. 「+」ボタン > Add package from git URL
3. 以下のURLを入力する

```
https://github.com/AnnulusGames/BurstLinq.git?path=/Assets/BurstLinq
```

あるいはPackages/manifest.jsonを開き、dependenciesブロックに以下を追記

```json
{
    "dependencies": {
        "com.annulusgames.burst-linq": "https://github.com/AnnulusGames/BurstLinq.git?path=/Assets/BurstLinq"
    }
}
```

## Quick Start

BurstLinqはSimdLinqと同様'Drop-in replacement'となるように設計されており、`using BurstLinq;`を含めるだけでBurstが適用可能な全てのオペレータに対して自動的にBurstLinqのメソッドを適用します。

```cs
using System.Collections.Generic;
using System.Linq;
using BurstLinq;

var enumerable = Enumerable.Range(0, 100);
var array = enumerable.ToArray();

// Enumerable.Sum()
var linqSum = enumerable.Sum();

// BurstLinqExtensions.Sum()
var burstLinqSum = array.Sum();
```

## サポートする型とオペレータ

BurstLinqが対応するオペレータと型の一覧は以下の通りです。

### サポートするコレクション型

* `T[]`
* `List<T>`
* `Memory<T>`
* `ReadOnlyMemory<T>`
* `Span<T>`
* `ReadOnlySpan<T>`
* `NativeArray<T>`
* `NativeList<T>`
* `NativeSlice<T>`

### サポートするオペレータ

* Sum (`int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)
* Average (`int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)
* Min (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`)
* Max (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`)
* Contains (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)
* SequenceEqual (`byte`, `sbyte`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, `Vector2`, `Vector3`, `Vector4`, `int2..4`, `uint2..4`, `float2..4`, `double2..4`)

## LINQとの互換性

BurstLinqはパフォーマンスの高さを優先するため、LINQと比べて挙動が異なる場合があります。使用する際は以下の違いに注意してください。

### Sum/Average

LINQのSumは`checked`ですが、BurstLinqは`unchecked`です。Burstはオーバーフローの検知をサポートしないため、Burstが無効化された際に動作の違いが生じないように`unchecked`としています。

### 浮動小数点型の扱い

BurstLinqのSumは`[BurstCompile(FloatMode = FloatMode.Fast)]`を指定するため、通常のLINQのSumと比較して計算結果に僅かな誤差が生じます。これが問題になることは稀ですが、互換性がないことには留意してください。

またBurstLinqはfloat/doubleに対するNaNのチェックを行わないため、その点にも注意してください。

## ライセンス

[MIT License](LICENSE)