using System;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using CullFactoryBurst;
using Unity.Burst;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.NormalizePlane_00000004$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.ExtractPlanes_00000005$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.TestPlanesAABB_00000006$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.ComputeBoundsHeightInterval_0000000B$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.AppendEdge_0000000C$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.ComputeCandidatesOnBoundsEdges_0000000D$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.ApplyFaceConfiguration_0000000E$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.ComputeCandidatesOnBoundsFaces_0000000F$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.EdgeHasPointInsideCone_00000010$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.CandidatesHavePointInsideCone_00000011$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.ConeIntersectsBounds_00000012$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CullFactoryBurst.IsRunningBurstLibrary_00000016$BurstDirectCall))]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[CompilerGenerated]
[EditorBrowsable(EditorBrowsableState.Never)]
[GeneratedCode("Unity.MonoScriptGenerator.MonoScriptInfoGenerator", null)]
internal class UnitySourceGeneratedAssemblyMonoScriptTypes_v1
{
	private struct MonoScriptData
	{
		public byte[] FilePathsData;

		public byte[] TypesData;

		public int TotalTypes;

		public int TotalFiles;

		public bool IsEditorOnly;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	private static MonoScriptData Get()
	{
		MonoScriptData result = default(MonoScriptData);
		result.FilePathsData = new byte[98]
		{
			0, 0, 0, 5, 0, 0, 0, 42, 92, 65,
			115, 115, 101, 116, 115, 92, 67, 117, 108, 108,
			70, 97, 99, 116, 111, 114, 121, 66, 117, 114,
			115, 116, 80, 108, 117, 103, 105, 110, 92, 71,
			101, 111, 109, 101, 116, 114, 121, 46, 99, 115,
			0, 0, 0, 1, 0, 0, 0, 40, 92, 65,
			115, 115, 101, 116, 115, 92, 67, 117, 108, 108,
			70, 97, 99, 116, 111, 114, 121, 66, 117, 114,
			115, 116, 80, 108, 117, 103, 105, 110, 92, 80,
			108, 117, 103, 105, 110, 46, 99, 115
		};
		result.TypesData = new byte[220]
		{
			0, 0, 0, 0, 25, 67, 117, 108, 108, 70,
			97, 99, 116, 111, 114, 121, 66, 117, 114, 115,
			116, 124, 71, 101, 111, 109, 101, 116, 114, 121,
			0, 0, 0, 0, 30, 67, 117, 108, 108, 70,
			97, 99, 116, 111, 114, 121, 66, 117, 114, 115,
			116, 46, 71, 101, 111, 109, 101, 116, 114, 121,
			124, 67, 111, 110, 101, 0, 0, 0, 0, 37,
			67, 117, 108, 108, 70, 97, 99, 116, 111, 114,
			121, 66, 117, 114, 115, 116, 46, 71, 101, 111,
			109, 101, 116, 114, 121, 124, 69, 100, 103, 101,
			73, 110, 100, 105, 99, 101, 115, 0, 0, 0,
			0, 38, 67, 117, 108, 108, 70, 97, 99, 116,
			111, 114, 121, 66, 117, 114, 115, 116, 46, 71,
			101, 111, 109, 101, 116, 114, 121, 124, 70, 97,
			99, 101, 73, 110, 100, 101, 120, 83, 101, 116,
			0, 0, 0, 0, 37, 67, 117, 108, 108, 70,
			97, 99, 116, 111, 114, 121, 66, 117, 114, 115,
			116, 46, 71, 101, 111, 109, 101, 116, 114, 121,
			124, 70, 97, 99, 101, 73, 110, 100, 105, 99,
			101, 115, 0, 0, 0, 0, 23, 67, 117, 108,
			108, 70, 97, 99, 116, 111, 114, 121, 66, 117,
			114, 115, 116, 124, 80, 108, 117, 103, 105, 110
		};
		result.TotalFiles = 2;
		result.TotalTypes = 6;
		result.IsEditorOnly = false;
		return result;
	}
}
namespace CullFactoryBurst;

[BurstCompile]
public static class Geometry
{
	private struct Cone
	{
		internal Vector3 origin;

		internal Vector3 direction;

		internal float length;

		internal float cosAngle;

		internal Cone(Vector3 origin, Vector3 direction, float length, float angle)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			this.origin = origin;
			this.direction = direction;
			this.length = length;
			cosAngle = math.cos(math.radians(angle / 2f));
		}
	}

	private struct EdgeIndices
	{
		internal int a;

		internal int b;

		internal EdgeIndices(int a, int b)
		{
			this.a = a;
			this.b = b;
		}
	}

	private struct FaceIndexSet
	{
		internal int a;

		internal int b;

		internal int c;

		internal int d;

		internal FaceIndexSet(int a, int b, int c, int d)
		{
			this.a = a;
			this.b = b;
			this.c = c;
			this.d = d;
		}
	}

	private struct FaceIndices
	{
		internal FaceIndexSet vertices;

		internal FaceIndexSet edges;

		internal FaceIndices(FaceIndexSet vertices, FaceIndexSet edges)
		{
			this.vertices = vertices;
			this.edges = edges;
		}
	}

	public delegate void NormalizePlane_00000004$PostfixBurstDelegate(in float4 plane, out float4 result);

	internal static class NormalizePlane_00000004$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(NormalizePlane_00000004$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static NormalizePlane_00000004$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(in float4 plane, out float4 result)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ref float4, ref float4, void>)functionPointer)(ref plane, ref result);
					return;
				}
			}
			NormalizePlane$BurstManaged(in plane, out result);
		}
	}

	public unsafe delegate void ExtractPlanes_00000005$PostfixBurstDelegate(in Matrix4x4 matrix, Plane* planes);

	internal static class ExtractPlanes_00000005$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(ExtractPlanes_00000005$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static ExtractPlanes_00000005$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(in Matrix4x4 matrix, Plane* planes)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ref Matrix4x4, Plane*, void>)functionPointer)(ref matrix, planes);
					return;
				}
			}
			ExtractPlanes$BurstManaged(in matrix, planes);
		}
	}

	public unsafe delegate bool TestPlanesAABB_00000006$PostfixBurstDelegate(Plane* planes, int planeCount, in Bounds bounds);

	internal static class TestPlanesAABB_00000006$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(TestPlanesAABB_00000006$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static TestPlanesAABB_00000006$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static bool Invoke(Plane* planes, int planeCount, in Bounds bounds)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					return ((delegate* unmanaged[Cdecl]<Plane*, int, ref Bounds, bool>)functionPointer)(planes, planeCount, ref bounds);
				}
			}
			return TestPlanesAABB$BurstManaged(planes, planeCount, in bounds);
		}
	}

	public delegate void ComputeBoundsHeightInterval_0000000B$PostfixBurstDelegate(in Bounds bounds, in Cone cone, out float minHeight, out float maxHeight);

	internal static class ComputeBoundsHeightInterval_0000000B$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(ComputeBoundsHeightInterval_0000000B$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static ComputeBoundsHeightInterval_0000000B$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(in Bounds bounds, in Cone cone, out float minHeight, out float maxHeight)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ref Bounds, ref Cone, ref float, ref float, void>)functionPointer)(ref bounds, ref cone, ref minHeight, ref maxHeight);
					return;
				}
			}
			ComputeBoundsHeightInterval$BurstManaged(in bounds, in cone, out minHeight, out maxHeight);
		}
	}

	public unsafe delegate void AppendEdge_0000000C$PostfixBurstDelegate(EdgeIndices* edges, ref int edgeCount, in EdgeIndices edge);

	internal static class AppendEdge_0000000C$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(AppendEdge_0000000C$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static AppendEdge_0000000C$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(EdgeIndices* edges, ref int edgeCount, in EdgeIndices edge)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<EdgeIndices*, ref int, ref EdgeIndices, void>)functionPointer)(edges, ref edgeCount, ref edge);
					return;
				}
			}
			AppendEdge$BurstManaged(edges, ref edgeCount, in edge);
		}
	}

	public unsafe delegate void ComputeCandidatesOnBoundsEdges_0000000D$PostfixBurstDelegate(in Cone cone, float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount);

	internal static class ComputeCandidatesOnBoundsEdges_0000000D$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(ComputeCandidatesOnBoundsEdges_0000000D$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static ComputeCandidatesOnBoundsEdges_0000000D$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(in Cone cone, float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ref Cone, float3*, float*, float*, EdgeIndices*, ref int, void>)functionPointer)(ref cone, vertices, projectionsMin, projectionsMax, candidates, ref candidateCount);
					return;
				}
			}
			ComputeCandidatesOnBoundsEdges$BurstManaged(in cone, vertices, projectionsMin, projectionsMax, candidates, ref candidateCount);
		}
	}

	public unsafe delegate void ApplyFaceConfiguration_0000000E$PostfixBurstDelegate(in FaceIndices face, float* projections, int baseIndex, EdgeIndices* candidates, ref int candidateCount);

	internal static class ApplyFaceConfiguration_0000000E$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(ApplyFaceConfiguration_0000000E$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static ApplyFaceConfiguration_0000000E$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(in FaceIndices face, float* projections, int baseIndex, EdgeIndices* candidates, ref int candidateCount)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ref FaceIndices, float*, int, EdgeIndices*, ref int, void>)functionPointer)(ref face, projections, baseIndex, candidates, ref candidateCount);
					return;
				}
			}
			ApplyFaceConfiguration$BurstManaged(in face, projections, baseIndex, candidates, ref candidateCount);
		}
	}

	public unsafe delegate void ComputeCandidatesOnBoundsFaces_0000000F$PostfixBurstDelegate(float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount);

	internal static class ComputeCandidatesOnBoundsFaces_0000000F$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(ComputeCandidatesOnBoundsFaces_0000000F$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static ComputeCandidatesOnBoundsFaces_0000000F$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<float3*, float*, float*, EdgeIndices*, ref int, void>)functionPointer)(vertices, projectionsMin, projectionsMax, candidates, ref candidateCount);
					return;
				}
			}
			ComputeCandidatesOnBoundsFaces$BurstManaged(vertices, projectionsMin, projectionsMax, candidates, ref candidateCount);
		}
	}

	public delegate bool EdgeHasPointInsideCone_00000010$PostfixBurstDelegate(in float3 pointA, in float3 pointB, in Cone cone);

	internal static class EdgeHasPointInsideCone_00000010$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(EdgeHasPointInsideCone_00000010$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static EdgeHasPointInsideCone_00000010$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static bool Invoke(in float3 pointA, in float3 pointB, in Cone cone)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					return ((delegate* unmanaged[Cdecl]<ref float3, ref float3, ref Cone, bool>)functionPointer)(ref pointA, ref pointB, ref cone);
				}
			}
			return EdgeHasPointInsideCone$BurstManaged(in pointA, in pointB, in cone);
		}
	}

	public unsafe delegate bool CandidatesHavePointInsideCone_00000011$PostfixBurstDelegate(in Cone cone, float3* vertices, EdgeIndices* candidates, int candidateCount);

	internal static class CandidatesHavePointInsideCone_00000011$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(CandidatesHavePointInsideCone_00000011$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static CandidatesHavePointInsideCone_00000011$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static bool Invoke(in Cone cone, float3* vertices, EdgeIndices* candidates, int candidateCount)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					return ((delegate* unmanaged[Cdecl]<ref Cone, float3*, EdgeIndices*, int, bool>)functionPointer)(ref cone, vertices, candidates, candidateCount);
				}
			}
			return CandidatesHavePointInsideCone$BurstManaged(in cone, vertices, candidates, candidateCount);
		}
	}

	public delegate bool ConeIntersectsBounds_00000012$PostfixBurstDelegate(in Cone cone, in Bounds bounds);

	internal static class ConeIntersectsBounds_00000012$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(ConeIntersectsBounds_00000012$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static ConeIntersectsBounds_00000012$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static bool Invoke(in Cone cone, in Bounds bounds)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					return ((delegate* unmanaged[Cdecl]<ref Cone, ref Bounds, bool>)functionPointer)(ref cone, ref bounds);
				}
			}
			return ConeIntersectsBounds$BurstManaged(in cone, in bounds);
		}
	}

	private static bool WarnedCallWasNotBurstCompiled = false;

	private static readonly EdgeIndices[] edges = new EdgeIndices[12]
	{
		new EdgeIndices(0, 1),
		new EdgeIndices(1, 3),
		new EdgeIndices(2, 3),
		new EdgeIndices(0, 2),
		new EdgeIndices(4, 5),
		new EdgeIndices(5, 7),
		new EdgeIndices(6, 7),
		new EdgeIndices(4, 6),
		new EdgeIndices(0, 4),
		new EdgeIndices(1, 5),
		new EdgeIndices(3, 7),
		new EdgeIndices(2, 6)
	};

	private const int CornerVertexCount = 8;

	private const int MaxVertexCount = 32;

	private const int ClipVerticesMinBaseIndex = 8;

	private const int ClipVerticesMaxBaseIndex = 20;

	private const int BoxEdgeCount = 12;

	private const int MaxEdgeCandidateCount = 496;

	private static readonly FaceIndices[] faces = new FaceIndices[6]
	{
		new FaceIndices(new FaceIndexSet(0, 4, 6, 2), new FaceIndexSet(8, 7, 11, 3)),
		new FaceIndices(new FaceIndexSet(1, 3, 7, 5), new FaceIndexSet(1, 10, 5, 9)),
		new FaceIndices(new FaceIndexSet(0, 1, 5, 4), new FaceIndexSet(0, 9, 4, 8)),
		new FaceIndices(new FaceIndexSet(2, 6, 7, 3), new FaceIndexSet(11, 6, 10, 2)),
		new FaceIndices(new FaceIndexSet(0, 2, 3, 1), new FaceIndexSet(3, 2, 1, 0)),
		new FaceIndices(new FaceIndexSet(4, 5, 7, 6), new FaceIndexSet(4, 5, 6, 7))
	};

	[BurstDiscard]
	public static void WarnIfNotBurstCompiled()
	{
		if (!WarnedCallWasNotBurstCompiled)
		{
			Debug.LogWarning((object)"Methods intended to be Burst-compiled in CullFactoryBurstPlugin are not using Burst.");
			WarnedCallWasNotBurstCompiled = true;
		}
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private static void NormalizePlane(in float4 plane, out float4 result)
	{
		NormalizePlane_00000004$BurstDirectCall.Invoke(in plane, out result);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static void ExtractPlanes(in Matrix4x4 matrix, Plane* planes)
	{
		ExtractPlanes_00000005$BurstDirectCall.Invoke(in matrix, planes);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static bool TestPlanesAABB(Plane* planes, int planeCount, in Bounds bounds)
	{
		return TestPlanesAABB_00000006$BurstDirectCall.Invoke(planes, planeCount, in bounds);
	}

	public unsafe static bool TestPlanesAABB(in Plane[] planes, in Bounds bounds)
	{
		if (planes.Length == 0)
		{
			return true;
		}
		return TestPlanesAABB((Plane*)UnsafeUtility.AddressOf<Plane>(ref planes[0]), planes.Length, in bounds);
	}

	public unsafe static bool TestPlanesAABB(in Span<Plane> planes, in Bounds bounds)
	{
		if (planes.Length == 0)
		{
			return true;
		}
		return TestPlanesAABB((Plane*)UnsafeUtility.AddressOf<Plane>(ref planes[0]), planes.Length, in bounds);
	}

	public unsafe static bool TestPlanesAABB(in NativeArray<Plane> planes, in Bounds bounds)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		return TestPlanesAABB((Plane*)NativeArrayUnsafeUtility.GetUnsafePtr<Plane>(planes), planes.Length, in bounds);
	}

	public unsafe static bool TestPlanesAABB(in NativeSlice<Plane> planes, in Bounds bounds)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		return TestPlanesAABB((Plane*)NativeSliceUnsafeUtility.GetUnsafePtr<Plane>(planes), planes.Length, in bounds);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private static void ComputeBoundsHeightInterval(in Bounds bounds, in Cone cone, out float minHeight, out float maxHeight)
	{
		ComputeBoundsHeightInterval_0000000B$BurstDirectCall.Invoke(in bounds, in cone, out minHeight, out maxHeight);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private unsafe static void AppendEdge(EdgeIndices* edges, ref int edgeCount, in EdgeIndices edge)
	{
		AppendEdge_0000000C$BurstDirectCall.Invoke(edges, ref edgeCount, in edge);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private unsafe static void ComputeCandidatesOnBoundsEdges(in Cone cone, float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount)
	{
		ComputeCandidatesOnBoundsEdges_0000000D$BurstDirectCall.Invoke(in cone, vertices, projectionsMin, projectionsMax, candidates, ref candidateCount);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private unsafe static void ApplyFaceConfiguration(in FaceIndices face, float* projections, int baseIndex, EdgeIndices* candidates, ref int candidateCount)
	{
		ApplyFaceConfiguration_0000000E$BurstDirectCall.Invoke(in face, projections, baseIndex, candidates, ref candidateCount);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private unsafe static void ComputeCandidatesOnBoundsFaces(float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount)
	{
		ComputeCandidatesOnBoundsFaces_0000000F$BurstDirectCall.Invoke(vertices, projectionsMin, projectionsMax, candidates, ref candidateCount);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private static bool EdgeHasPointInsideCone(in float3 pointA, in float3 pointB, in Cone cone)
	{
		return EdgeHasPointInsideCone_00000010$BurstDirectCall.Invoke(in pointA, in pointB, in cone);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private unsafe static bool CandidatesHavePointInsideCone(in Cone cone, float3* vertices, EdgeIndices* candidates, int candidateCount)
	{
		return CandidatesHavePointInsideCone_00000011$BurstDirectCall.Invoke(in cone, vertices, candidates, candidateCount);
	}

	[BurstCompile(/*Could not decode attribute arguments.*/)]
	private static bool ConeIntersectsBounds(in Cone cone, in Bounds bounds)
	{
		return ConeIntersectsBounds_00000012$BurstDirectCall.Invoke(in cone, in bounds);
	}

	public static bool SpotLightInfluencesBounds(in Light light, in Bounds bounds)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		Transform transform = ((Component)light).transform;
		Cone cone = new Cone(transform.position, transform.forward, light.range, light.spotAngle);
		return ConeIntersectsBounds(in cone, in bounds);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public static void NormalizePlane$BurstManaged(in float4 plane, out float4 result)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		float4 val = plane;
		float4 val2 = plane;
		result = val / math.length(((float4)(ref val2)).xyz);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static void ExtractPlanes$BurstManaged(in Matrix4x4 matrix, Plane* planes)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		Matrix4x4 val = matrix;
		Vector4 row = ((Matrix4x4)(ref val)).GetRow(3);
		val = matrix;
		float4 plane = float4.op_Implicit(row + ((Matrix4x4)(ref val)).GetRow(0));
		NormalizePlane(in plane, out *(float4*)planes);
		val = matrix;
		plane = float4.op_Implicit(row - ((Matrix4x4)(ref val)).GetRow(0));
		NormalizePlane(in plane, out *(float4*)((byte*)planes + Unsafe.SizeOf<float4>()));
		val = matrix;
		plane = float4.op_Implicit(row - ((Matrix4x4)(ref val)).GetRow(1));
		NormalizePlane(in plane, out *(float4*)((byte*)planes + (nint)2 * (nint)Unsafe.SizeOf<float4>()));
		val = matrix;
		plane = float4.op_Implicit(row + ((Matrix4x4)(ref val)).GetRow(1));
		NormalizePlane(in plane, out *(float4*)((byte*)planes + (nint)3 * (nint)Unsafe.SizeOf<float4>()));
		val = matrix;
		plane = float4.op_Implicit(row - ((Matrix4x4)(ref val)).GetRow(2));
		NormalizePlane(in plane, out *(float4*)((byte*)planes + (nint)4 * (nint)Unsafe.SizeOf<float4>()));
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static bool TestPlanesAABB$BurstManaged(Plane* planes, int planeCount, in Bounds bounds)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		WarnIfNotBurstCompiled();
		for (int i = 0; i < planeCount; i++)
		{
			Plane val = (Plane)((byte*)planes)[(nint)i * (nint)Unsafe.SizeOf<Plane>()];
			float3 val2 = float3.op_Implicit(((Plane)(ref val)).normal);
			Bounds val3 = bounds;
			float num = math.dot(val2, float3.op_Implicit(((Bounds)(ref val3)).center));
			float3 val4 = math.abs(float3.op_Implicit(((Plane)(ref val)).normal));
			val3 = bounds;
			float num2 = math.dot(val4, float3.op_Implicit(((Bounds)(ref val3)).extents));
			if (num + num2 + ((Plane)(ref val)).distance <= 0f)
			{
				return false;
			}
		}
		return true;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public static void ComputeBoundsHeightInterval$BurstManaged(in Bounds bounds, in Cone cone, out float minHeight, out float maxHeight)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		Bounds val = bounds;
		float3 val2 = float3.op_Implicit(((Bounds)(ref val)).center);
		val = bounds;
		float3 val3 = float3.op_Implicit(((Bounds)(ref val)).extents);
		float3 val4 = float3.op_Implicit(cone.origin);
		float3 val5 = float3.op_Implicit(cone.direction);
		float num = math.dot(val5, val2 - val4);
		val = bounds;
		float num2 = ((Bounds)(ref val)).extents.x * math.abs(val5.x);
		val = bounds;
		float num3 = num2 + ((Bounds)(ref val)).extents.y * math.abs(val5.y) + val3.z * math.abs(val5.z);
		minHeight = num - num3;
		maxHeight = num + num3;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static void AppendEdge$BurstManaged(EdgeIndices* edges, ref int edgeCount, in EdgeIndices edge)
	{
		edges[edgeCount++] = edge;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static void ComputeCandidatesOnBoundsEdges$BurstManaged(in Cone cone, float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 8; i++)
		{
			float num = math.dot(float3.op_Implicit(cone.direction), (float3)((byte*)vertices)[(nint)i * (nint)Unsafe.SizeOf<float3>()]);
			projectionsMin[i] = 0f - num;
			projectionsMax[i] = num - cone.length;
		}
		int num2 = 8;
		int num3 = 20;
		for (int num4 = 0; num4 < 12; num4++)
		{
			EdgeIndices edge = edges[num4];
			float num5 = projectionsMin[edge.a];
			float num6 = projectionsMin[edge.b];
			int num7;
			if (!(num5 < 0f) || !(num6 > 0f))
			{
				if (num5 > 0f)
				{
					num7 = ((num6 < 0f) ? 1 : 0);
					if (num7 != 0)
					{
						goto IL_00ab;
					}
				}
				else
				{
					num7 = 0;
				}
				goto IL_0104;
			}
			num7 = 1;
			goto IL_00ab;
			IL_00ab:
			Unsafe.Write((byte*)vertices + (nint)num2 * (nint)Unsafe.SizeOf<float3>(), (num6 * (float3)((byte*)vertices)[(nint)edge.a * (nint)Unsafe.SizeOf<float3>()] - num5 * (float3)((byte*)vertices)[(nint)edge.b * (nint)Unsafe.SizeOf<float3>()]) / (num6 - num5));
			goto IL_0104;
			IL_0104:
			float num8 = projectionsMax[edge.a];
			float num9 = projectionsMax[edge.b];
			bool flag = (num8 < 0f && num9 > 0f) || (num8 > 0f && num9 < 0f);
			if (flag)
			{
				Unsafe.Write((byte*)vertices + (nint)num3 * (nint)Unsafe.SizeOf<float3>(), (num9 * (float3)((byte*)vertices)[(nint)edge.a * (nint)Unsafe.SizeOf<float3>()] - num8 * (float3)((byte*)vertices)[(nint)edge.b * (nint)Unsafe.SizeOf<float3>()]) / (num9 - num8));
			}
			if (num7 != 0)
			{
				if (flag)
				{
					EdgeIndices edge2 = new EdgeIndices(num2, num3);
					AppendEdge(candidates, ref candidateCount, in edge2);
				}
				else if (num5 < 0f)
				{
					EdgeIndices edge2 = new EdgeIndices(edge.a, num2);
					AppendEdge(candidates, ref candidateCount, in edge2);
				}
				else
				{
					EdgeIndices edge2 = new EdgeIndices(edge.b, num2);
					AppendEdge(candidates, ref candidateCount, in edge2);
				}
			}
			else if (flag)
			{
				if (num8 < 0f)
				{
					EdgeIndices edge2 = new EdgeIndices(edge.a, num3);
					AppendEdge(candidates, ref candidateCount, in edge2);
				}
				else
				{
					EdgeIndices edge2 = new EdgeIndices(edge.b, num3);
					AppendEdge(candidates, ref candidateCount, in edge2);
				}
			}
			else if (num5 <= 0f && num6 <= 0f && num8 <= 0f && num9 <= 0f)
			{
				AppendEdge(candidates, ref candidateCount, in edge);
			}
			num2++;
			num3++;
		}
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static void ApplyFaceConfiguration$BurstManaged(in FaceIndices face, float* projections, int baseIndex, EdgeIndices* candidates, ref int candidateCount)
	{
		float num = projections[face.vertices.a];
		float num2 = projections[face.vertices.b];
		float num3 = projections[face.vertices.c];
		float num4 = projections[face.vertices.d];
		int num5 = ((!(num < 0f)) ? ((!(num > 0f)) ? 1 : 2) : 0);
		int num6 = ((!(num2 < 0f)) ? ((!(num2 > 0f)) ? 1 : 2) : 0);
		int num7 = ((!(num3 < 0f)) ? ((!(num3 > 0f)) ? 1 : 2) : 0);
		switch (((!(num4 < 0f)) ? ((!(num4 > 0f)) ? 1 : 2) : 0) + 3 * (num7 + 3 * (num6 + 3 * num5)))
		{
		case 2:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, baseIndex + face.edges.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 5:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.c, baseIndex + face.edges.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 6:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.b, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 7:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 8:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.b, baseIndex + face.edges.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 11:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 14:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 15:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 16:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.b, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 17:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 18:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 19:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 20:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 21:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 22:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 23:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 24:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 25:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 26:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, baseIndex + face.edges.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 29:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 32:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 33:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 34:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 35:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 38:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.d, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 41:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.d, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 42:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 43:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 45:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 46:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.b, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 47:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.b, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 48:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 49:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 51:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 54:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 55:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.d, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 56:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 57:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 58:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 59:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.c, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 60:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 61:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.a, baseIndex + face.edges.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(baseIndex + face.edges.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, face.vertices.d);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 62:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.a, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 63:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 64:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.d, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 65:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 66:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 69:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, face.vertices.a);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.a, face.vertices.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.b, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			edge = new EdgeIndices(face.vertices.c, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 72:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 73:
		{
			EdgeIndices edge = new EdgeIndices(face.vertices.d, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 74:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, baseIndex + face.edges.b);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 75:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.c, face.vertices.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 78:
		{
			EdgeIndices edge = new EdgeIndices(baseIndex + face.edges.d, baseIndex + face.edges.c);
			AppendEdge(candidates, ref candidateCount, in edge);
			break;
		}
		case 3:
		case 4:
		case 9:
		case 10:
		case 12:
		case 13:
		case 27:
		case 28:
		case 30:
		case 31:
		case 36:
		case 37:
		case 39:
		case 40:
		case 44:
		case 50:
		case 52:
		case 53:
		case 67:
		case 68:
		case 70:
		case 71:
		case 76:
		case 77:
			break;
		}
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static void ComputeCandidatesOnBoundsFaces$BurstManaged(float3* vertices, float* projectionsMin, float* projectionsMax, EdgeIndices* candidates, ref int candidateCount)
	{
		for (int i = 0; i < 6; i++)
		{
			FaceIndices face = faces[i];
			ApplyFaceConfiguration(in face, projectionsMin, 8, candidates, ref candidateCount);
			ApplyFaceConfiguration(in face, projectionsMax, 20, candidates, ref candidateCount);
		}
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public static bool EdgeHasPointInsideCone$BurstManaged(in float3 pointA, in float3 pointB, in Cone cone)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		if (math.dot(float3.op_Implicit(cone.direction), pointA) - cone.cosAngle * math.length(pointA) > 0f)
		{
			return true;
		}
		if (math.dot(float3.op_Implicit(cone.direction), pointB) - cone.cosAngle * math.length(pointB) > 0f)
		{
			return true;
		}
		float3 val = pointB - pointA;
		float3 val2 = math.cross(pointA, float3.op_Implicit(cone.direction));
		float3 val3 = math.cross(pointA, val);
		float num = math.dot(val3, val2);
		if (num > 0f)
		{
			float3 val4 = math.cross(pointB, float3.op_Implicit(cone.direction));
			float num2 = math.dot(val3, val4);
			if (num2 < 0f)
			{
				float num3 = num / (num - num2);
				float3 val5 = pointA + num3 * val;
				if (math.dot(float3.op_Implicit(cone.direction), val5) - cone.cosAngle * math.length(val5) > 0f)
				{
					return true;
				}
			}
		}
		return false;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static bool CandidatesHavePointInsideCone$BurstManaged(in Cone cone, float3* vertices, EdgeIndices* candidates, int candidateCount)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < candidateCount; i++)
		{
			EdgeIndices edgeIndices = candidates[i];
			float3 pointA = (float3)((byte*)vertices)[(nint)edgeIndices.a * (nint)Unsafe.SizeOf<float3>()];
			float3 pointB = (float3)((byte*)vertices)[(nint)edgeIndices.b * (nint)Unsafe.SizeOf<float3>()];
			if (EdgeHasPointInsideCone(in pointA, in pointB, in cone))
			{
				return true;
			}
		}
		return false;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile(/*Could not decode attribute arguments.*/)]
	public unsafe static bool ConeIntersectsBounds$BurstManaged(in Cone cone, in Bounds bounds)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		WarnIfNotBurstCompiled();
		ComputeBoundsHeightInterval(in bounds, in cone, out var minHeight, out var maxHeight);
		if (maxHeight <= 0f || minHeight >= cone.length)
		{
			return false;
		}
		Bounds val = bounds;
		float num = default(float);
		if (((Bounds)(ref val)).IntersectRay(new Ray(cone.origin, cone.direction), ref num))
		{
			return true;
		}
		val = bounds;
		float3 val2 = float3.op_Implicit(((Bounds)(ref val)).min);
		val = bounds;
		float3 val3 = float3.op_Implicit(((Bounds)(ref val)).max);
		float3 val4 = float3.op_Implicit(cone.origin);
		float3* ptr = (float3*)stackalloc float3[32];
		Unsafe.Write(ptr, new float3(val2.x, val2.y, val2.z) - val4);
		Unsafe.Write((byte*)ptr + Unsafe.SizeOf<float3>(), new float3(val3.x, val2.y, val2.z) - val4);
		Unsafe.Write((byte*)ptr + (nint)2 * (nint)Unsafe.SizeOf<float3>(), new float3(val2.x, val3.y, val2.z) - val4);
		Unsafe.Write((byte*)ptr + (nint)3 * (nint)Unsafe.SizeOf<float3>(), new float3(val3.x, val3.y, val2.z) - val4);
		Unsafe.Write((byte*)ptr + (nint)4 * (nint)Unsafe.SizeOf<float3>(), new float3(val2.x, val2.y, val3.z) - val4);
		Unsafe.Write((byte*)ptr + (nint)5 * (nint)Unsafe.SizeOf<float3>(), new float3(val3.x, val2.y, val3.z) - val4);
		Unsafe.Write((byte*)ptr + (nint)6 * (nint)Unsafe.SizeOf<float3>(), new float3(val2.x, val3.y, val3.z) - val4);
		Unsafe.Write((byte*)ptr + (nint)7 * (nint)Unsafe.SizeOf<float3>(), new float3(val3.x, val3.y, val3.z) - val4);
		EdgeIndices* ptr2 = stackalloc EdgeIndices[1024];
		int candidateCount = 0;
		if (minHeight >= 0f && maxHeight <= cone.length)
		{
			for (int i = 0; i < 12; i++)
			{
				ptr2[i] = edges[i];
				candidateCount++;
			}
			return CandidatesHavePointInsideCone(in cone, ptr, ptr2, candidateCount);
		}
		float* projectionsMin = stackalloc float[8];
		float* projectionsMax = stackalloc float[8];
		ComputeCandidatesOnBoundsEdges(in cone, ptr, projectionsMin, projectionsMax, ptr2, ref candidateCount);
		ComputeCandidatesOnBoundsFaces(ptr, projectionsMin, projectionsMax, ptr2, ref candidateCount);
		return CandidatesHavePointInsideCone(in cone, ptr, ptr2, candidateCount);
	}
}
[BurstCompile]
public static class Plugin
{
	public delegate bool IsRunningBurstLibrary_00000016$PostfixBurstDelegate();

	internal static class IsRunningBurstLibrary_00000016$BurstDirectCall
	{
		private static IntPtr Pointer;

		private static IntPtr DeferredCompilation;

		[BurstDiscard]
		private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
		{
			if (Pointer == (IntPtr)0)
			{
				Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(IsRunningBurstLibrary_00000016$PostfixBurstDelegate).TypeHandle);
			}
			P_0 = Pointer;
		}

		private static IntPtr GetFunctionPointer()
		{
			nint result = 0;
			GetFunctionPointerDiscard(ref result);
			return result;
		}

		public static void Constructor()
		{
			DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
		}

		public static void Initialize()
		{
		}

		static IsRunningBurstLibrary_00000016$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static bool Invoke()
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					return ((delegate* unmanaged[Cdecl]<bool>)functionPointer)();
				}
			}
			return IsRunningBurstLibrary$BurstManaged();
		}
	}

	[BurstDiscard]
	private static void SetValueFalseIfManaged(ref bool value)
	{
		value = false;
	}

	[BurstCompile]
	public static bool IsRunningBurstLibrary()
	{
		return IsRunningBurstLibrary_00000016$BurstDirectCall.Invoke();
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile]
	public static bool IsRunningBurstLibrary$BurstManaged()
	{
		bool value = true;
		SetValueFalseIfManaged(ref value);
		return value;
	}
}
internal static class $BurstDirectCallInitializer
{
	[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
	private static void Initialize()
	{
		Geometry.NormalizePlane_00000004$BurstDirectCall.Initialize();
		Geometry.ExtractPlanes_00000005$BurstDirectCall.Initialize();
		Geometry.TestPlanesAABB_00000006$BurstDirectCall.Initialize();
		Geometry.ComputeBoundsHeightInterval_0000000B$BurstDirectCall.Initialize();
		Geometry.AppendEdge_0000000C$BurstDirectCall.Initialize();
		Geometry.ComputeCandidatesOnBoundsEdges_0000000D$BurstDirectCall.Initialize();
		Geometry.ApplyFaceConfiguration_0000000E$BurstDirectCall.Initialize();
		Geometry.ComputeCandidatesOnBoundsFaces_0000000F$BurstDirectCall.Initialize();
		Geometry.EdgeHasPointInsideCone_00000010$BurstDirectCall.Initialize();
		Geometry.CandidatesHavePointInsideCone_00000011$BurstDirectCall.Initialize();
		Geometry.ConeIntersectsBounds_00000012$BurstDirectCall.Initialize();
		Plugin.IsRunningBurstLibrary_00000016$BurstDirectCall.Initialize();
	}
}