using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalPerformance.Patcher.Helpers;
using LethalPerformance.Patcher.TomlConverters;
using LethalPerformance.Patcher.Utilities;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("BepInEx")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalPerformance.Patcher")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.0.0")]
[assembly: AssemblyInformationalVersion("0.5.0+faf437aa490b684a62dd1968099116df944f4430")]
[assembly: AssemblyProduct("LethalPerformance.Patcher")]
[assembly: AssemblyTitle("LethalPerformance.Patcher")]
[assembly: InternalsVisibleTo("LethalPerformance")]
[assembly: InternalsVisibleTo("LethalPerformance.Dev")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LethalPerformance.Patcher
{
	public class LethalPerformancePatcher
	{
		public static Harmony? Harmony { get; set; }

		public static ManualLogSource Logger { get; } = Logger.CreateLogSource("LethalPeformance.Patcher");


		public static ConfigSaverTask ConfigSaverTask { get; } = new ConfigSaverTask();


		public static IEnumerable<string> TargetDLLs { get; } = new <>z__ReadOnlySingleElementList<string>("Assembly-CSharp.dll");


		public static void Finish()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			Harmony = new Harmony("LethalPerformance.Patcher");
			Harmony.PatchAll(typeof(LethalPerformancePatcher).Assembly);
			Harmony.UnpatchID("org.bepinex.fixes.harmonyinterop");
			TomlTypeConverter.TypeConverters[typeof(string)] = (TypeConverter)(object)new StringTomlConverter();
			TomlTypeConverter.TypeConverters[typeof(bool)] = (TypeConverter)(object)new BoolTomlConverter();
		}

		public static void Patch(AssemblyDefinition assembly)
		{
			Dictionary<string, Action<AssemblyDefinition, TypeDefinition>> dictionary = new Dictionary<string, Action<AssemblyDefinition, TypeDefinition>>
			{
				{
					"AudioReverbPresets",
					delegate(AssemblyDefinition a, TypeDefinition t)
					{
						AssemblyPatcherUtilities.AddMethod(a, t, "Awake");
					}
				},
				{
					"animatedSun",
					delegate(AssemblyDefinition a, TypeDefinition t)
					{
						AssemblyPatcherUtilities.RemoveMethod(a, t, "Update");
					}
				}
			};
			Collection<TypeDefinition> types = assembly.MainModule.Types;
			foreach (KeyValuePair<string, Action<AssemblyDefinition, TypeDefinition>> item in dictionary)
			{
				item.Deconstruct(out var key, out var value);
				string typeName = key;
				Action<AssemblyDefinition, TypeDefinition> action = value;
				TypeDefinition val = ((IEnumerable<TypeDefinition>)types).FirstOrDefault((Func<TypeDefinition, bool>)((TypeDefinition t) => ((MemberReference)t).Name == typeName));
				if (val == null)
				{
					Logger.LogWarning((object)("Failed to patch " + typeName));
				}
				else
				{
					action(assembly, val);
				}
			}
		}
	}
}
namespace LethalPerformance.Patcher.Utilities
{
	internal static class AssemblyPatcherUtilities
	{
		public static void RemoveMethod(AssemblyDefinition assembly, TypeDefinition type, string methodName)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<MethodDefinition> enumerator = type.Methods.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					MethodDefinition current = enumerator.Current;
					if (((MemberReference)current).Name == methodName)
					{
						type.Methods.Remove(current);
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public static void AddMethod(AssemblyDefinition assembly, TypeDefinition type, string methodName)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			string methodName2 = methodName;
			if (!((IEnumerable<MethodDefinition>)type.Methods).Any((MethodDefinition m) => ((MemberReference)m).Name == methodName2))
			{
				MethodDefinition val = new MethodDefinition(methodName2, (MethodAttributes)1, assembly.MainModule.TypeSystem.Void);
				ILProcessor iLProcessor = val.Body.GetILProcessor();
				StubMethod(iLProcessor);
				type.Methods.Add(val);
			}
		}

		private static void StubMethod(ILProcessor processor)
		{
			//IL_0005: 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)
			for (int i = 0; i < 32; i++)
			{
				processor.Emit(OpCodes.Nop);
			}
			processor.Emit(OpCodes.Ret);
		}
	}
	public class ConfigSaverTask
	{
		private readonly HashSet<ConfigFile> m_ConfigFilesToSave = new HashSet<ConfigFile>();

		private readonly HashSet<ConfigFile> m_IgnoredConfigFiles = new HashSet<ConfigFile>();

		public void ScheduleSaveFor(ConfigFile configFile)
		{
			if (!m_IgnoredConfigFiles.Contains(configFile))
			{
				m_ConfigFilesToSave.Add(configFile);
			}
		}

		public void AddIgnoredConfigFile(ConfigFile configFile)
		{
			if (!m_IgnoredConfigFiles.Add(configFile))
			{
				return;
			}
			foreach (ConfigFile ignoredConfigFile in m_IgnoredConfigFiles)
			{
				m_ConfigFilesToSave.Remove(ignoredConfigFile);
			}
		}

		public void ScheduleSave()
		{
			if (m_ConfigFilesToSave.Count != 0)
			{
				Queue<ConfigFile> param = new Queue<ConfigFile>(m_ConfigFilesToSave);
				m_ConfigFilesToSave.Clear();
				AsyncHelper.Schedule(SaveAsync, param);
			}
		}

		public void Save()
		{
			if (m_ConfigFilesToSave.Count != 0)
			{
				Queue<ConfigFile> queue = new Queue<ConfigFile>(m_ConfigFilesToSave);
				m_ConfigFilesToSave.Clear();
				SaveAsync(queue);
			}
		}

		private Task SaveAsync(Queue<ConfigFile> queue)
		{
			int count = queue.Count;
			ConfigFile result;
			while (queue.TryDequeue(out result))
			{
				result.Save();
			}
			LethalPerformancePatcher.Logger.LogInfo((object)$"Saved {count} config(s)");
			return Task.CompletedTask;
		}
	}
}
namespace LethalPerformance.Patcher.TomlConverters
{
	internal class BoolTomlConverter : TypeConverter<bool>
	{
		public override bool ConvertToObject(string value)
		{
			return bool.Parse(value);
		}

		public override string ConvertToString(bool value)
		{
			if (!value)
			{
				return "false";
			}
			return "true";
		}
	}
	internal class StringTomlConverter : TypeConverter<string>
	{
		private static readonly Regex s_WindowsPathRegex = new Regex("^\"?\\w:\\\\(?!\\\\)(?!.+\\\\\\\\)", RegexOptions.Compiled);

		public override string ConvertToObject(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			if (s_WindowsPathRegex.IsMatch(value))
			{
				return value;
			}
			return Unescape(value);
		}

		public override string ConvertToString(string value)
		{
			return Escape(value);
		}

		private static string Escape(string txt)
		{
			if (string.IsNullOrEmpty(txt))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(txt.Length + 2);
			foreach (char c in txt)
			{
				switch (c)
				{
				case '\0':
					stringBuilder.Append("\\0");
					break;
				case '\a':
					stringBuilder.Append("\\a");
					break;
				case '\b':
					stringBuilder.Append("\\b");
					break;
				case '\t':
					stringBuilder.Append("\\t");
					break;
				case '\n':
					stringBuilder.Append("\\n");
					break;
				case '\v':
					stringBuilder.Append("\\v");
					break;
				case '\f':
					stringBuilder.Append("\\f");
					break;
				case '\r':
					stringBuilder.Append("\\r");
					break;
				case '\'':
					stringBuilder.Append("\\'");
					break;
				case '"':
					stringBuilder.Append("\\\"");
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			if (stringBuilder.Length == txt.Length)
			{
				return txt;
			}
			return stringBuilder.ToString();
		}

		private static string Unescape(string txt)
		{
			if (string.IsNullOrEmpty(txt))
			{
				return txt;
			}
			int num = txt.IndexOf('\\');
			if (num == -1)
			{
				return txt;
			}
			StringBuilder stringBuilder = new StringBuilder(txt.Length);
			stringBuilder.Append(txt, 0, num);
			int num2 = num;
			while (num2 < txt.Length)
			{
				int num3 = txt.IndexOf('\\', num2);
				if (num3 < 0 || num3 == txt.Length - 1)
				{
					num3 = txt.Length;
				}
				stringBuilder.Append(txt, num2, num3 - num2);
				if (num3 >= txt.Length)
				{
					break;
				}
				char c = txt[num3 + 1];
				switch (c)
				{
				case '0':
					stringBuilder.Append('\0');
					break;
				case 'a':
					stringBuilder.Append('\a');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'v':
					stringBuilder.Append('\v');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case '\'':
					stringBuilder.Append('\'');
					break;
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				default:
					stringBuilder.Append('\\').Append(c);
					break;
				}
				num2 = num3 + 2;
			}
			return stringBuilder.ToString();
		}
	}
	internal abstract class TypeConverter<T> : TypeConverter where T : IEquatable<T>
	{
		protected TypeConverter()
		{
			((TypeConverter)this).ConvertToObject = (string value, Type _) => ConvertToObject(value);
			((TypeConverter)this).ConvertToString = (object value, Type _) => ConvertToString((T)value);
		}

		public abstract T ConvertToObject(string value);

		public abstract string ConvertToString(T value);
	}
}
namespace LethalPerformance.Patcher.Patches
{
	[HarmonyPatch(typeof(Chainloader))]
	internal static class Patch_Chainloader
	{
		private static Dictionary<string, PluginInfo>? s_PluginsToLoad;

		internal static bool IsModWillBeLoaded(string guid)
		{
			return s_PluginsToLoad?.ContainsKey(guid) ?? false;
		}

		[HarmonyPatch("Initialize")]
		[HarmonyPostfix]
		private static void Initialize()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			try
			{
				LethalPerformancePatcher.Harmony.Patch((MethodBase)MethodOf(new Action(Chainloader.Start)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(MethodOf(new Func<IEnumerable<CodeInstruction>, IEnumerable<CodeInstruction>>(SaveListOfPluginsTranspiler))), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				LethalPerformancePatcher.Logger.LogWarning((object)ex);
			}
		}

		private static MethodInfo MethodOf(Delegate @delegate)
		{
			return @delegate.Method;
		}

		private static IEnumerable<CodeInstruction> SaveListOfPluginsTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null);
			object operand = val.SearchForward((Func<CodeInstruction, bool>)((CodeInstruction c) => c.operand is FieldInfo fieldInfo && fieldInfo.FieldType == typeof(Dictionary<string, PluginInfo>))).Operand;
			val.Start().MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Newarr, (object)typeof(string), (string)null),
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)null, (string)null)
			}).ThrowIfInvalid("Failed to get injection point")
				.Insert((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, operand),
					new CodeInstruction(OpCodes.Stsfld, (object)typeof(Patch_Chainloader).GetField("s_PluginsToLoad", AccessTools.all))
				});
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ConfigDefinition))]
	internal static class Patch_ConfigDefinition
	{
		private static readonly MethodInfo s_TargetMethod = typeof(Patch_ConfigDefinition).GetMethod("CheckInvalidConfigCharsOptimized", AccessTools.all);

		[HarmonyPatch("CheckInvalidConfigChars")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> CallCheckInvalidConfigCharsOptimized()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			return new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[4]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)s_TargetMethod),
				new CodeInstruction(OpCodes.Ret, (object)null)
			});
		}

		private static void CheckInvalidConfigCharsOptimized(string value, string name)
		{
			if (value == null)
			{
				throw new ArgumentNullException(name);
			}
			ReadOnlySpan<char> span = value.AsSpan().Trim();
			if (!span.SequenceEqual(value))
			{
				throw new ArgumentException("Cannot use whitespace characters at start or end of section and key names", name);
			}
			if (span.IndexOfAny(ConfigDefinition._invalidConfigChars) >= 0)
			{
				throw new ArgumentException("Cannot use any of the following characters in section and key names: = \\n \\t \\ \" ' [ ]", name);
			}
		}
	}
	[HarmonyPatch(typeof(ConfigEntryBase))]
	internal static class Patch_ConfigEntryBase
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void ScheduleSave(ConfigFile configFile)
		{
			LethalPerformancePatcher.ConfigSaverTask.ScheduleSaveFor(configFile);
		}

		[HarmonyPatch("WriteDescription")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> CallWriteDescriptionOptimized()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			return new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[4]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => WriteDescriptionOptimized(null, null)))),
				new CodeInstruction(OpCodes.Ret, (object)null)
			});
		}

		public static void WriteDescriptionOptimized(ConfigEntryBase instance, StreamWriter writer)
		{
			if (!string.IsNullOrEmpty(instance.Description.Description))
			{
				writer.Write("## ");
				string description = instance.Description.Description;
				foreach (char c in description)
				{
					writer.Write(c);
					if (c == '\n')
					{
						writer.Write("## ");
					}
				}
				writer.WriteLine();
			}
			writer.Write("# Setting type: ");
			writer.WriteLine(instance.SettingType.Name);
			writer.Write("# Default value: ");
			writer.WriteLine(TomlTypeConverter.ConvertToString(instance.DefaultValue, instance.SettingType));
			if (instance.Description.AcceptableValues != null)
			{
				writer.WriteLine(instance.Description.AcceptableValues.ToDescriptionString());
			}
			else
			{
				if (!instance.SettingType.IsEnum)
				{
					return;
				}
				writer.Write("# Acceptable values: ");
				string[] orCreate = EnumCacheHelper.GetOrCreate(instance.SettingType);
				for (int j = 0; j < orCreate.Length; j++)
				{
					string value = orCreate[j];
					writer.Write(value);
					if (j != orCreate.Length - 1)
					{
						writer.Write(", ");
					}
				}
				writer.WriteLine();
				if (instance.SettingType.IsDefined(typeof(FlagsAttribute), inherit: false))
				{
					writer.WriteLine("# Multiple values can be set at the same time by separating them with , (e.g. Debug, Warning)");
				}
			}
		}
	}
	[HarmonyPatch(typeof(ConfigFile))]
	internal static class Patch_ConfigFile
	{
		private static bool s_IgnoreConfigSet;

		[HarmonyPatch("Reload")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> CallOptimizedReload()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			return new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => OptimizedReload(null)))),
				new CodeInstruction(OpCodes.Ret, (object)null)
			});
		}

		[HarmonyPatch("Save")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> CallOptimizedSave()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			return new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => SaveOptimized(null)))),
				new CodeInstruction(OpCodes.Ret, (object)null)
			});
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void SetFalseForSaveOnConfigSet(ConfigFile __instance, bool saveOnInit)
		{
			s_IgnoreConfigSet = true;
			__instance.SaveOnConfigSet = false;
			s_IgnoreConfigSet = false;
			if (saveOnInit)
			{
				LethalPerformancePatcher.ConfigSaverTask.ScheduleSaveFor(__instance);
			}
			__instance.SettingChanged += delegate(object _, SettingChangedEventArgs arg)
			{
				LethalPerformancePatcher.ConfigSaverTask.ScheduleSaveFor(arg.ChangedSetting.ConfigFile);
			};
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void AddIgnoreIfSetToFalse(ConfigFile __instance, bool value)
		{
			if (!s_IgnoreConfigSet && !value)
			{
				LethalPerformancePatcher.ConfigSaverTask.AddIgnoredConfigFile(__instance);
			}
		}

		private static void OptimizedReload(ConfigFile instance)
		{
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			lock (instance._ioLock)
			{
				instance.OrphanedEntries.Clear();
				using StreamReader streamReader = new StreamReader(instance.ConfigFilePath, Encoding.UTF8);
				string text = string.Empty;
				Span<Range> ranges = stackalloc Range[2];
				string text2;
				while ((text2 = streamReader.ReadLine()) != null)
				{
					ReadOnlySpan<char> readOnlySpan = text2.AsSpan().Trim();
					if (readOnlySpan.IsEmpty || readOnlySpan.StartsWith("#"))
					{
						continue;
					}
					if (readOnlySpan.StartsWith("[") && readOnlySpan.EndsWith("]"))
					{
						text = readOnlySpan.Slice(1, readOnlySpan.Length - 2).ToString();
					}
					else if (SpanExtensions.Split(readOnlySpan, ranges, '='))
					{
						Range range = ranges[0];
						ReadOnlySpan<char> readOnlySpan2 = readOnlySpan[range.Start..range.End].Trim();
						range = ranges[1];
						ReadOnlySpan<char> readOnlySpan3 = readOnlySpan[range.Start..range.End].Trim();
						ConfigDefinition key = new ConfigDefinition(text, readOnlySpan2.ToString());
						if (instance.Entries.TryGetValue(key, out var value))
						{
							value.SetSerializedValue(readOnlySpan3.ToString());
						}
						else
						{
							instance.OrphanedEntries[key] = readOnlySpan3.ToString();
						}
					}
				}
			}
			instance.OnConfigReloaded();
		}

		private static void SaveOptimized(ConfigFile instance)
		{
			lock (instance._ioLock)
			{
				string directoryName = Path.GetDirectoryName(instance.ConfigFilePath);
				if (!Directory.Exists(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				Span<char> destination = stackalloc char[128];
				using StreamWriter streamWriter = new StreamWriter(instance.ConfigFilePath, append: false, Utility.UTF8NoBom);
				if (instance._ownerMetadata != null)
				{
					streamWriter.Write("## Settings file was created by plugin ");
					streamWriter.Write(instance._ownerMetadata.Name);
					streamWriter.Write(" v");
					instance._ownerMetadata.Version.TryFormat(destination, out var charsWritten);
					streamWriter.WriteLine(destination.Slice(0, charsWritten));
					streamWriter.Write("## Plugin GUID: ");
					streamWriter.WriteLine(instance._ownerMetadata.GUID);
					streamWriter.WriteLine();
				}
				var second = instance.OrphanedEntries.Select((KeyValuePair<ConfigDefinition, string> x) => new
				{
					Key = x.Key,
					entry = (ConfigEntryBase)null,
					value = x.Value
				});
				var first = instance.Entries.Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> x) => new
				{
					Key = x.Key,
					entry = x.Value,
					value = (string)null
				});
				var orderedEnumerable = from x in first.Concat(second)
					group x by x.Key.Section into x
					orderby x.Key
					select x;
				foreach (var item in orderedEnumerable)
				{
					streamWriter.Write('[');
					streamWriter.Write(item.Key);
					streamWriter.WriteLine(']');
					foreach (var item2 in item)
					{
						streamWriter.WriteLine();
						ConfigEntryBase entry = item2.entry;
						if (entry != null)
						{
							entry.WriteDescription(streamWriter);
						}
						object obj = item2.value;
						if (obj == null)
						{
							ConfigEntryBase entry2 = item2.entry;
							obj = ((entry2 != null) ? entry2.GetSerializedValue() : null) ?? string.Empty;
						}
						string value = (string)obj;
						streamWriter.Write(item2.Key.Key);
						streamWriter.Write(" = ");
						streamWriter.WriteLine(value);
					}
					streamWriter.WriteLine();
				}
			}
		}
	}
	[HarmonyPatch]
	internal class Patch_FileSystemWatcher
	{
		private static readonly MethodInfo? s_StartDispatching;

		private static readonly FieldInfo? s_Watches;

		static Patch_FileSystemWatcher()
		{
			Type type = typeof(FileSystemWatcher).Assembly.GetType("System.IO.DefaultWatcher", throwOnError: false);
			if (!(type == null))
			{
				s_StartDispatching = type.GetMethod("StartDispatching", AccessTools.all);
				s_Watches = type.GetField("watches", AccessTools.all);
				s_Watches?.SetValue(null, new Hashtable());
			}
		}

		[HarmonyPrepare]
		private static bool ShouldPatch()
		{
			return s_StartDispatching != null;
		}

		[HarmonyTargetMethod]
		private static MethodInfo? GetTargetPatch()
		{
			return s_StartDispatching;
		}

		[HarmonyPrefix]
		private static bool DisableDefaultWatcher()
		{
			return false;
		}
	}
}
namespace LethalPerformance.Patcher.Helpers
{
	internal static class AsyncHelper
	{
		public static void Schedule(Func<Task> func)
		{
			Func<Task> func2 = func;
			Task.Run(async delegate
			{
				try
				{
					await func2();
				}
				catch (Exception ex)
				{
					LethalPerformancePatcher.Logger.LogError((object)ex);
				}
			});
		}

		public static void Schedule<T>(Func<T, Task> func, T param1)
		{
			Func<T, Task> func2 = func;
			T param2 = param1;
			Task.Run(async delegate
			{
				try
				{
					await func2(param2);
				}
				catch (Exception ex)
				{
					LethalPerformancePatcher.Logger.LogError((object)ex);
				}
			});
		}
	}
	internal static class EnumCacheHelper
	{
		private static readonly Dictionary<Type, string[]> s_EnumNamesCache = new Dictionary<Type, string[]>();

		public static string[] GetOrCreate(Type enumType)
		{
			if (s_EnumNamesCache.Count >= 255)
			{
				s_EnumNamesCache.Clear();
			}
			if (s_EnumNamesCache.TryGetValue(enumType, out string[] value))
			{
				return value;
			}
			string[] names = Enum.GetNames(enumType);
			s_EnumNamesCache[enumType] = names;
			return names;
		}
	}
	internal static class SpanExtensions
	{
		public static bool Split(ReadOnlySpan<char> input, Span<Range> ranges, char separator)
		{
			if (ranges.IsEmpty && ranges.Length != 2)
			{
				return false;
			}
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (c == separator)
				{
					ranges[0] = 0..i;
					ranges[1] = (i + 1)..input.Length;
					return true;
				}
			}
			return false;
		}
	}
}
namespace LethalPerformance.Patcher.API
{
	internal static class HarmonyExceptionHandler
	{
		public static Exception? ReportException(Exception? exception)
		{
			if (exception != null)
			{
				LethalPerformancePatcher.Logger.LogWarning((object)exception);
				LethalPerformancePatcher.Logger.LogWarning((object)Environment.StackTrace);
			}
			return null;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class InitializeOnAwakeAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}

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 LethalPerformance.Unity;
using Unity.Burst;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Rendering.HighDefinition;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: StaticTypeReinit(typeof(LethalPerformance.Unity.UpdateShaderVariablesXRCB_00000003$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(LethalPerformance.Unity.UpdateShaderVariablesGlobalCB_00000004$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[48]
		{
			0, 0, 0, 4, 0, 0, 0, 40, 92, 65,
			115, 115, 101, 116, 115, 92, 76, 101, 116, 104,
			97, 108, 80, 101, 114, 102, 111, 114, 109, 97,
			110, 99, 101, 92, 67, 97, 109, 101, 114, 97,
			66, 117, 114, 115, 116, 46, 99, 115
		};
		result.TypesData = new byte[238]
		{
			0, 0, 0, 0, 35, 76, 101, 116, 104, 97,
			108, 80, 101, 114, 102, 111, 114, 109, 97, 110,
			99, 101, 46, 85, 110, 105, 116, 121, 124, 67,
			97, 109, 101, 114, 97, 66, 117, 114, 115, 116,
			0, 0, 0, 0, 57, 76, 101, 116, 104, 97,
			108, 80, 101, 114, 102, 111, 114, 109, 97, 110,
			99, 101, 46, 85, 110, 105, 116, 121, 46, 67,
			97, 109, 101, 114, 97, 66, 117, 114, 115, 116,
			124, 82, 101, 97, 100, 97, 98, 108, 101, 86,
			105, 101, 119, 67, 111, 110, 115, 116, 97, 110,
			116, 115, 0, 0, 0, 0, 61, 76, 101, 116,
			104, 97, 108, 80, 101, 114, 102, 111, 114, 109,
			97, 110, 99, 101, 46, 85, 110, 105, 116, 121,
			46, 67, 97, 109, 101, 114, 97, 66, 117, 114,
			115, 116, 124, 82, 101, 97, 100, 97, 98, 108,
			101, 83, 104, 97, 100, 101, 114, 86, 97, 114,
			105, 97, 98, 108, 101, 115, 88, 82, 0, 0,
			0, 0, 65, 76, 101, 116, 104, 97, 108, 80,
			101, 114, 102, 111, 114, 109, 97, 110, 99, 101,
			46, 85, 110, 105, 116, 121, 46, 67, 97, 109,
			101, 114, 97, 66, 117, 114, 115, 116, 124, 82,
			101, 97, 100, 97, 98, 108, 101, 83, 104, 97,
			100, 101, 114, 86, 97, 114, 105, 97, 98, 108,
			101, 115, 71, 108, 111, 98, 97, 108
		};
		result.TotalFiles = 1;
		result.TotalTypes = 4;
		result.IsEditorOnly = false;
		return result;
	}
}
namespace LethalPerformance.Unity;

[BurstCompile]
public static class CameraBurst
{
	public readonly struct ReadableViewConstants
	{
		public readonly Matrix4x4 viewMatrix;

		public readonly Matrix4x4 invViewMatrix;

		public readonly Matrix4x4 projMatrix;

		public readonly Matrix4x4 invProjMatrix;

		public readonly Matrix4x4 viewProjMatrix;

		public readonly Matrix4x4 invViewProjMatrix;

		public readonly Matrix4x4 nonJitteredViewProjMatrix;

		public readonly Matrix4x4 prevViewMatrix;

		public readonly Matrix4x4 prevViewProjMatrix;

		public readonly Matrix4x4 prevInvViewProjMatrix;

		public readonly Matrix4x4 prevViewProjMatrixNoCameraTrans;

		public readonly Matrix4x4 pixelCoordToViewDirWS;

		public readonly Matrix4x4 viewProjectionNoCameraTrans;

		public readonly Vector3 worldSpaceCameraPos;

		internal readonly float pad0;

		public readonly Vector3 worldSpaceCameraPosViewOffset;

		internal readonly float pad1;

		public readonly Vector3 prevWorldSpaceCameraPos;

		internal readonly float pad2;
	}

	public struct ReadableShaderVariablesXR
	{
		public unsafe fixed float _XRViewMatrix[32];

		public unsafe fixed float _XRInvViewMatrix[32];

		public unsafe fixed float _XRProjMatrix[32];

		public unsafe fixed float _XRInvProjMatrix[32];

		public unsafe fixed float _XRViewProjMatrix[32];

		public unsafe fixed float _XRInvViewProjMatrix[32];

		public unsafe fixed float _XRNonJitteredViewProjMatrix[32];

		public unsafe fixed float _XRPrevViewProjMatrix[32];

		public unsafe fixed float _XRPrevInvViewProjMatrix[32];

		public unsafe fixed float _XRPrevViewProjMatrixNoCameraTrans[32];

		public unsafe fixed float _XRViewProjMatrixNoCameraTrans[32];

		public unsafe fixed float _XRPixelCoordToViewDirWS[32];

		public unsafe fixed float _XRWorldSpaceCameraPos[8];

		public unsafe fixed float _XRWorldSpaceCameraPosViewOffset[8];

		public unsafe fixed float _XRPrevWorldSpaceCameraPos[8];
	}

	public struct ReadableShaderVariablesGlobal
	{
		public Matrix4x4 _ViewMatrix;

		public Matrix4x4 _CameraViewMatrix;

		public Matrix4x4 _InvViewMatrix;

		public Matrix4x4 _ProjMatrix;

		public Matrix4x4 _InvProjMatrix;

		public Matrix4x4 _ViewProjMatrix;

		public Matrix4x4 _CameraViewProjMatrix;

		public Matrix4x4 _InvViewProjMatrix;

		public Matrix4x4 _NonJitteredViewProjMatrix;

		public Matrix4x4 _PrevViewProjMatrix;

		public Matrix4x4 _PrevInvViewProjMatrix;

		public Vector4 _WorldSpaceCameraPos_Internal;

		public Vector4 _PrevCamPosRWS_Internal;

		public Vector4 _ScreenSize;

		public Vector4 _PostProcessScreenSize;

		public Vector4 _RTHandleScale;

		public Vector4 _RTHandleScaleHistory;

		public Vector4 _RTHandlePostProcessScale;

		public Vector4 _RTHandlePostProcessScaleHistory;

		public Vector4 _DynamicResolutionFullscreenScale;

		public Vector4 _ZBufferParams;

		public Vector4 _ProjectionParams;

		public Vector4 unity_OrthoParams;

		public Vector4 _ScreenParams;

		public unsafe fixed float _FrustumPlanes[24];

		public unsafe fixed float _ShadowFrustumPlanes[24];

		public Vector4 _TaaFrameInfo;

		public Vector4 _TaaJitterStrength;

		public Vector4 _Time;

		public Vector4 _SinTime;

		public Vector4 _CosTime;

		public Vector4 unity_DeltaTime;

		public Vector4 _TimeParameters;

		public Vector4 _LastTimeParameters;

		public int _FogEnabled;

		public int _PBRFogEnabled;

		public int _EnableVolumetricFog;

		public float _MaxFogDistance;

		public Vector4 _FogColor;

		public float _FogColorMode;

		public float _GlobalMipBias;

		public float _GlobalMipBiasPow2;

		public float _Pad0;

		public Vector4 _MipFogParameters;

		public Vector4 _HeightFogBaseScattering;

		public float _HeightFogBaseExtinction;

		public float _HeightFogBaseHeight;

		public float _GlobalFogAnisotropy;

		public int _VolumetricFilteringEnabled;

		public Vector2 _HeightFogExponents;

		public int _FogDirectionalOnly;

		public float _FogGIDimmer;

		public Vector4 _VBufferViewportSize;

		public Vector4 _VBufferLightingViewportScale;

		public Vector4 _VBufferLightingViewportLimit;

		public Vector4 _VBufferDistanceEncodingParams;

		public Vector4 _VBufferDistanceDecodingParams;

		public uint _VBufferSliceCount;

		public float _VBufferRcpSliceCount;

		public float _VBufferRcpInstancedViewCount;

		public float _VBufferLastSliceDist;

		public Vector4 _ShadowAtlasSize;

		public Vector4 _CascadeShadowAtlasSize;

		public Vector4 _AreaShadowAtlasSize;

		public Vector4 _CachedShadowAtlasSize;

		public Vector4 _CachedAreaShadowAtlasSize;

		public int _ReflectionsMode;

		public int _UnusedPadding0;

		public int _UnusedPadding1;

		public int _UnusedPadding2;

		public uint _DirectionalLightCount;

		public uint _PunctualLightCount;

		public uint _AreaLightCount;

		public uint _EnvLightCount;

		public int _EnvLightSkyEnabled;

		public uint _CascadeShadowCount;

		public int _DirectionalShadowIndex;

		public uint _EnableLightLayers;

		public uint _EnableSkyReflection;

		public uint _EnableSSRefraction;

		public float _SSRefractionInvScreenWeightDistance;

		public float _ColorPyramidLodCount;

		public float _DirectionalTransmissionMultiplier;

		public float _ProbeExposureScale;

		public float _ContactShadowOpacity;

		public float _ReplaceDiffuseForIndirect;

		public Vector4 _AmbientOcclusionParam;

		public float _IndirectDiffuseLightingMultiplier;

		public uint _IndirectDiffuseLightingLayers;

		public float _ReflectionLightingMultiplier;

		public uint _ReflectionLightingLayers;

		public float _MicroShadowOpacity;

		public uint _EnableProbeVolumes;

		public uint _ProbeVolumeCount;

		public float _SlopeScaleDepthBias;

		public Vector4 _CookieAtlasSize;

		public Vector4 _CookieAtlasData;

		public Vector4 _ReflectionAtlasCubeData;

		public Vector4 _ReflectionAtlasPlanarData;

		public uint _NumTileFtplX;

		public uint _NumTileFtplY;

		public float g_fClustScale;

		public float g_fClustBase;

		public float g_fNearPlane;

		public float g_fFarPlane;

		public int g_iLog2NumClusters;

		public uint g_isLogBaseBufferEnabled;

		public uint _NumTileClusteredX;

		public uint _NumTileClusteredY;

		public int _EnvSliceSize;

		public uint _EnableDecalLayers;

		public unsafe fixed float _ShapeParamsAndMaxScatterDists[64];

		public unsafe fixed float _TransmissionTintsAndFresnel0[64];

		public unsafe fixed float _WorldScalesAndFilterRadiiAndThicknessRemaps[64];

		public unsafe fixed float _DiffusionProfileHashTable[64];

		public uint _EnableSubsurfaceScattering;

		public uint _TexturingModeFlags;

		public uint _TransmissionFlags;

		public uint _DiffusionProfileCount;

		public Vector2 _DecalAtlasResolution;

		public uint _EnableDecals;

		public uint _DecalCount;

		public float _OffScreenDownsampleFactor;

		public uint _OffScreenRendering;

		public uint _XRViewCount;

		public int _FrameCount;

		public Vector4 _CoarseStencilBufferSize;

		public int _IndirectDiffuseMode;

		public int _EnableRayTracedReflections;

		public int _RaytracingFrameIndex;

		public uint _EnableRecursiveRayTracing;

		public int _TransparentCameraOnlyMotionVectors;

		public float _GlobalTessellationFactorMultiplier;

		public float _SpecularOcclusionBlend;

		public float _DeExposureMultiplier;

		public Vector4 _ScreenSizeOverride;

		public Vector4 _ScreenCoordScaleBias;
	}

	public unsafe delegate void UpdateShaderVariablesXRCB_00000003$PostfixBurstDelegate(in ReadableViewConstants* xrViewConstants, in int viewCount, ReadableShaderVariablesXR* cb);

	internal static class UpdateShaderVariablesXRCB_00000003$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(UpdateShaderVariablesXRCB_00000003$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 UpdateShaderVariablesXRCB_00000003$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(in ReadableViewConstants* xrViewConstants, in int viewCount, ReadableShaderVariablesXR* cb)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ref ReadableViewConstants*, ref int, ReadableShaderVariablesXR*, void>)functionPointer)(ref xrViewConstants, ref viewCount, cb);
					return;
				}
			}
			UpdateShaderVariablesXRCB$BurstManaged(in xrViewConstants, in viewCount, cb);
		}
	}

	public unsafe delegate void UpdateShaderVariablesGlobalCB_00000004$PostfixBurstDelegate(ReadableShaderVariablesGlobal* cb, in FrameSettings frameSettings, in AntialiasingMode antialiasingMode, in CameraType cameraType, in ReadableViewConstants* mainViewConstants, in float4x4 vectorParams, in float4x4 vectorParams2, in float4x4 vectorParams3, in float4* frustumPlaneEquations, in float taaSharpenStrength, in int taaFrameIndex, in int colorPyramidHistoryMipCount, in float globalMipBias, in float time, in float lastTime, in int frameCount, in int viewCount, in float probeRangeCompressionFactor, in float deExposureMultiplier, in float4 screenCoordScaleBias, in bool useScreenSizeOverride, in float4 screenSizeOverride);

	internal static class UpdateShaderVariablesGlobalCB_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(UpdateShaderVariablesGlobalCB_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 UpdateShaderVariablesGlobalCB_00000004$BurstDirectCall()
		{
			Constructor();
		}

		public unsafe static void Invoke(ReadableShaderVariablesGlobal* cb, in FrameSettings frameSettings, in AntialiasingMode antialiasingMode, in CameraType cameraType, in ReadableViewConstants* mainViewConstants, in float4x4 vectorParams, in float4x4 vectorParams2, in float4x4 vectorParams3, in float4* frustumPlaneEquations, in float taaSharpenStrength, in int taaFrameIndex, in int colorPyramidHistoryMipCount, in float globalMipBias, in float time, in float lastTime, in int frameCount, in int viewCount, in float probeRangeCompressionFactor, in float deExposureMultiplier, in float4 screenCoordScaleBias, in bool useScreenSizeOverride, in float4 screenSizeOverride)
		{
			if (BurstCompiler.IsEnabled)
			{
				IntPtr functionPointer = GetFunctionPointer();
				if (functionPointer != (IntPtr)0)
				{
					((delegate* unmanaged[Cdecl]<ReadableShaderVariablesGlobal*, ref FrameSettings, ref AntialiasingMode, ref CameraType, ref ReadableViewConstants*, ref float4x4, ref float4x4, ref float4x4, ref float4*, ref float, ref int, ref int, ref float, ref float, ref float, ref int, ref int, ref float, ref float, ref float4, ref bool, ref float4, void>)functionPointer)(cb, ref frameSettings, ref antialiasingMode, ref cameraType, ref mainViewConstants, ref vectorParams, ref vectorParams2, ref vectorParams3, ref frustumPlaneEquations, ref taaSharpenStrength, ref taaFrameIndex, ref colorPyramidHistoryMipCount, ref globalMipBias, ref time, ref lastTime, ref frameCount, ref viewCount, ref probeRangeCompressionFactor, ref deExposureMultiplier, ref screenCoordScaleBias, ref useScreenSizeOverride, ref screenSizeOverride);
					return;
				}
			}
			UpdateShaderVariablesGlobalCB$BurstManaged(cb, in frameSettings, in antialiasingMode, in cameraType, in mainViewConstants, in vectorParams, in vectorParams2, in vectorParams3, in frustumPlaneEquations, in taaSharpenStrength, in taaFrameIndex, in colorPyramidHistoryMipCount, in globalMipBias, in time, in lastTime, in frameCount, in viewCount, in probeRangeCompressionFactor, in deExposureMultiplier, in screenCoordScaleBias, in useScreenSizeOverride, in screenSizeOverride);
		}
	}

	[BurstCompile]
	public unsafe static void UpdateShaderVariablesXRCB(in ReadableViewConstants* xrViewConstants, in int viewCount, ReadableShaderVariablesXR* cb)
	{
		UpdateShaderVariablesXRCB_00000003$BurstDirectCall.Invoke(in xrViewConstants, in viewCount, cb);
	}

	[BurstCompile]
	public unsafe static void UpdateShaderVariablesGlobalCB(ReadableShaderVariablesGlobal* cb, in FrameSettings frameSettings, in AntialiasingMode antialiasingMode, in CameraType cameraType, in ReadableViewConstants* mainViewConstants, in float4x4 vectorParams, in float4x4 vectorParams2, in float4x4 vectorParams3, in float4* frustumPlaneEquations, in float taaSharpenStrength, in int taaFrameIndex, in int colorPyramidHistoryMipCount, in float globalMipBias, in float time, in float lastTime, in int frameCount, in int viewCount, in float probeRangeCompressionFactor, in float deExposureMultiplier, in float4 screenCoordScaleBias, in bool useScreenSizeOverride, in float4 screenSizeOverride)
	{
		UpdateShaderVariablesGlobalCB_00000004$BurstDirectCall.Invoke(cb, in frameSettings, in antialiasingMode, in cameraType, in mainViewConstants, in vectorParams, in vectorParams2, in vectorParams3, in frustumPlaneEquations, in taaSharpenStrength, in taaFrameIndex, in colorPyramidHistoryMipCount, in globalMipBias, in time, in lastTime, in frameCount, in viewCount, in probeRangeCompressionFactor, in deExposureMultiplier, in screenCoordScaleBias, in useScreenSizeOverride, in screenSizeOverride);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile]
	public unsafe static void UpdateShaderVariablesXRCB$BurstManaged(in ReadableViewConstants* xrViewConstants, in int viewCount, ReadableShaderVariablesXR* cb)
	{
		for (int i = 0; i < viewCount; i++)
		{
			UnsafeUtility.MemCpy((void*)(cb->_XRViewMatrix + i * 15), (void*)(&xrViewConstants[i].viewMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRInvViewMatrix + i * 15), (void*)(&xrViewConstants[i].invViewMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRProjMatrix + i * 15), (void*)(&xrViewConstants[i].projMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRInvProjMatrix + i * 15), (void*)(&xrViewConstants[i].invProjMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRViewProjMatrix + i * 15), (void*)(&xrViewConstants[i].viewProjMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRInvViewProjMatrix + i * 15), (void*)(&xrViewConstants[i].invViewProjMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRNonJitteredViewProjMatrix + i * 15), (void*)(&xrViewConstants[i].nonJitteredViewProjMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRPrevViewProjMatrix + i * 15), (void*)(&xrViewConstants[i].prevViewProjMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRPrevInvViewProjMatrix + i * 15), (void*)(&xrViewConstants[i].prevInvViewProjMatrix), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRViewProjMatrixNoCameraTrans + i * 15), (void*)(&xrViewConstants[i].viewProjectionNoCameraTrans), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRPrevViewProjMatrixNoCameraTrans + i * 15), (void*)(&xrViewConstants[i].prevViewProjMatrixNoCameraTrans), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRPixelCoordToViewDirWS + i * 15), (void*)(&xrViewConstants[i].pixelCoordToViewDirWS), (long)Unsafe.SizeOf<float4x4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRWorldSpaceCameraPos + i * 4), (void*)(&xrViewConstants[i].worldSpaceCameraPos), (long)Unsafe.SizeOf<float4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRWorldSpaceCameraPosViewOffset + i * 4), (void*)(&xrViewConstants[i].worldSpaceCameraPosViewOffset), (long)Unsafe.SizeOf<float4>());
			UnsafeUtility.MemCpy((void*)(cb->_XRPrevWorldSpaceCameraPos + i * 4), (void*)(&xrViewConstants[i].prevWorldSpaceCameraPos), (long)Unsafe.SizeOf<float4>());
		}
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[BurstCompile]
	public unsafe static void UpdateShaderVariablesGlobalCB$BurstManaged(ReadableShaderVariablesGlobal* cb, in FrameSettings frameSettings, in AntialiasingMode antialiasingMode, in CameraType cameraType, in ReadableViewConstants* mainViewConstants, in float4x4 vectorParams, in float4x4 vectorParams2, in float4x4 vectorParams3, in float4* frustumPlaneEquations, in float taaSharpenStrength, in int taaFrameIndex, in int colorPyramidHistoryMipCount, in float globalMipBias, in float time, in float lastTime, in int frameCount, in int viewCount, in float probeRangeCompressionFactor, in float deExposureMultiplier, in float4 screenCoordScaleBias, in bool useScreenSizeOverride, in float4 screenSizeOverride)
	{
		//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_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_0032: 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_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_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: 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_0086: 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_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_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: 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_00b5: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: 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)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: 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_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_015a: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0167: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: 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_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_019c: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_020f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_023a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0247: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0256: Unknown result type (might be due to invalid IL or missing references)
		//IL_025b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_0272: Unknown result type (might be due to invalid IL or missing references)
		//IL_0277: Unknown result type (might be due to invalid IL or missing references)
		//IL_027c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_0293: Unknown result type (might be due to invalid IL or missing references)
		//IL_0298: Unknown result type (might be due to invalid IL or missing references)
		//IL_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02db: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		//IL_0306: Unknown result type (might be due to invalid IL or missing references)
		//IL_0362: Unknown result type (might be due to invalid IL or missing references)
		//IL_0367: Unknown result type (might be due to invalid IL or missing references)
		//IL_036c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0406: Unknown result type (might be due to invalid IL or missing references)
		//IL_040b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0410: Unknown result type (might be due to invalid IL or missing references)
		//IL_042e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0433: Unknown result type (might be due to invalid IL or missing references)
		//IL_0438: Unknown result type (might be due to invalid IL or missing references)
		//IL_0456: Unknown result type (might be due to invalid IL or missing references)
		//IL_045b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0460: Unknown result type (might be due to invalid IL or missing references)
		//IL_049b: Unknown result type (might be due to invalid IL or missing references)
		//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
		FrameSettings val = frameSettings;
		bool flag = ((FrameSettings)(ref val)).IsEnabled((FrameSettingsField)15) && (int)antialiasingMode == 2 && (int)cameraType == 1;
		Unsafe.Write(&cb->_ViewMatrix, mainViewConstants->viewMatrix);
		Unsafe.Write(&cb->_CameraViewMatrix, mainViewConstants->viewMatrix);
		Unsafe.Write(&cb->_InvViewMatrix, mainViewConstants->invViewMatrix);
		Unsafe.Write(&cb->_ProjMatrix, mainViewConstants->projMatrix);
		Unsafe.Write(&cb->_InvProjMatrix, mainViewConstants->invProjMatrix);
		Unsafe.Write(&cb->_ViewProjMatrix, mainViewConstants->viewProjMatrix);
		Unsafe.Write(&cb->_CameraViewProjMatrix, mainViewConstants->viewProjMatrix);
		Unsafe.Write(&cb->_InvViewProjMatrix, mainViewConstants->invViewProjMatrix);
		Unsafe.Write(&cb->_NonJitteredViewProjMatrix, mainViewConstants->nonJitteredViewProjMatrix);
		Unsafe.Write(&cb->_PrevViewProjMatrix, mainViewConstants->prevViewProjMatrix);
		Unsafe.Write(&cb->_PrevInvViewProjMatrix, mainViewConstants->prevInvViewProjMatrix);
		Unsafe.Write(&cb->_WorldSpaceCameraPos_Internal, Vector4.op_Implicit(mainViewConstants->worldSpaceCameraPos));
		Unsafe.Write(&cb->_PrevCamPosRWS_Internal, Vector4.op_Implicit(mainViewConstants->prevWorldSpaceCameraPos));
		float4x4 val2 = vectorParams;
		Unsafe.Write(&cb->_ScreenSize, float4.op_Implicit(((float4x4)(ref val2))[0]));
		val2 = vectorParams;
		Unsafe.Write(&cb->_PostProcessScreenSize, float4.op_Implicit(((float4x4)(ref val2))[1]));
		val2 = vectorParams;
		Unsafe.Write(&cb->_RTHandleScale, float4.op_Implicit(((float4x4)(ref val2))[2]));
		val2 = vectorParams;
		Unsafe.Write(&cb->_RTHandleScaleHistory, float4.op_Implicit(((float4x4)(ref val2))[3]));
		val2 = vectorParams2;
		Unsafe.Write(&cb->_RTHandlePostProcessScale, float4.op_Implicit(((float4x4)(ref val2))[0]));
		val2 = vectorParams2;
		Unsafe.Write(&cb->_RTHandlePostProcessScaleHistory, float4.op_Implicit(((float4x4)(ref val2))[1]));
		val2 = vectorParams2;
		float num = ((float4)(ref ((float4x4)(ref val2))[2]))[0];
		val2 = vectorParams2;
		float num2 = num / ((float4)(ref ((float4x4)(ref val2))[2]))[1];
		val2 = vectorParams2;
		float num3 = ((float4)(ref ((float4x4)(ref val2))[2]))[2];
		val2 = vectorParams2;
		Unsafe.Write(&cb->_DynamicResolutionFullscreenScale, float4.op_Implicit(new float4(num2, num3 / ((float4)(ref ((float4x4)(ref val2))[2]))[3], 0f, 0f)));
		val2 = vectorParams2;
		Unsafe.Write(&cb->_ZBufferParams, float4.op_Implicit(((float4x4)(ref val2))[3]));
		val2 = vectorParams3;
		Unsafe.Write(&cb->_ProjectionParams, float4.op_Implicit(((float4x4)(ref val2))[0]));
		val2 = vectorParams3;
		Unsafe.Write(&cb->unity_OrthoParams, float4.op_Implicit(((float4x4)(ref val2))[1]));
		val2 = vectorParams3;
		Unsafe.Write(&cb->_ScreenParams, float4.op_Implicit(((float4x4)(ref val2))[2]));
		UnsafeUtility.MemCpy((void*)cb->_FrustumPlanes, (void*)frustumPlaneEquations, (long)(Unsafe.SizeOf<float4>() * 6));
		Unsafe.Write(&cb->_TaaFrameInfo, float4.op_Implicit(new float4(taaSharpenStrength, 0f, (float)taaFrameIndex, flag ? 1f : 0f)));
		val2 = vectorParams3;
		Unsafe.Write(&cb->_TaaJitterStrength, float4.op_Implicit(((float4x4)(ref val2))[3]));
		cb->_ColorPyramidLodCount = colorPyramidHistoryMipCount;
		cb->_GlobalMipBias = globalMipBias;
		cb->_GlobalMipBiasPow2 = (float)math.pow(2.0, (double)globalMipBias);
		float deltaTime = Time.deltaTime;
		float smoothDeltaTime = Time.smoothDeltaTime;
		Unsafe.Write(&cb->_Time, float4.op_Implicit(new float4(time * 0.05f, time, time * 2f, time * 3f)));
		Unsafe.Write(&cb->_SinTime, float4.op_Implicit(new float4(math.sin(time * 0.125f), math.sin(time * 0.25f), math.sin(time * 0.5f), math.sin(time))));
		Unsafe.Write(&cb->_CosTime, float4.op_Implicit(new float4(math.cos(time * 0.125f), math.cos(time * 0.25f), math.cos(time * 0.5f), math.cos(time))));
		Unsafe.Write(&cb->unity_DeltaTime, float4.op_Implicit(new float4(deltaTime, 1f / deltaTime, smoothDeltaTime, 1f / smoothDeltaTime)));
		Unsafe.Write(&cb->_TimeParameters, float4.op_Implicit(new float4(time, math.sin(time), math.cos(time), 0f)));
		Unsafe.Write(&cb->_LastTimeParameters, float4.op_Implicit(new float4(lastTime, math.sin(lastTime), math.cos(lastTime), 0f)));
		cb->_FrameCount = frameCount;
		cb->_XRViewCount = (uint)viewCount;
		cb->_ProbeExposureScale = 1f / math.max(probeRangeCompressionFactor, 1E-06f);
		cb->_DeExposureMultiplier = deExposureMultiplier;
		val = frameSettings;
		int transparentCameraOnlyMotionVectors;
		if (((FrameSettings)(ref val)).IsEnabled((FrameSettingsField)10))
		{
			val = frameSettings;
			if (!((FrameSettings)(ref val)).IsEnabled((FrameSettingsField)16))
			{
				transparentCameraOnlyMotionVectors = 1;
				goto IL_04c2;
			}
		}
		transparentCameraOnlyMotionVectors = 0;
		goto IL_04c2;
		IL_04c2:
		cb->_TransparentCameraOnlyMotionVectors = transparentCameraOnlyMotionVectors;
		Unsafe.Write(&cb->_ScreenCoordScaleBias, float4.op_Implicit(screenCoordScaleBias));
		Unsafe.Write(&cb->_ScreenSizeOverride, useScreenSizeOverride ? float4.op_Implicit(screenSizeOverride) : cb->_ScreenSize);
	}
}
internal static class $BurstDirectCallInitializer
{
	[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
	private static void Initialize()
	{
		CameraBurst.UpdateShaderVariablesXRCB_00000003$BurstDirectCall.Initialize();
		CameraBurst.UpdateShaderVariablesGlobalCB_00000004$BurstDirectCall.Initialize();
	}
}