using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RealisticNose")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("RealisticNose")]
[assembly: AssemblyTitle("RealisticNose")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 RealisticNose
{
	internal static class NoseSwapper
	{
		private static Mesh _source;

		private static readonly Dictionary<int, Mesh> Originals = new Dictionary<int, Mesh>();

		private static readonly Dictionary<int, Mesh> Fitted = new Dictionary<int, Mesh>();

		private static ManualLogSource Log => Plugin.Log;

		public static bool LoadModel()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			string text = ResolveModelPath(Plugin.ObjFile.Value);
			bool flag = default(bool);
			if (text == null)
			{
				ManualLogSource log = Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(56, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("model '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Plugin.ObjFile.Value);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' not found next to the plugin ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("or anywhere under ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Paths.PluginPath);
				}
				log.LogError(val);
				return false;
			}
			string error;
			Mesh val2 = ObjMesh.Load(text, Plugin.InvertFaces.Value, out error);
			if ((Object)(object)val2 == (Object)null)
			{
				ManualLogSource log2 = Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(17, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("failed to read ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Path.GetFileName(text));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(error);
				}
				log2.LogError(val);
				return false;
			}
			((Object)val2).hideFlags = (HideFlags)61;
			_source = val2;
			Fitted.Clear();
			Bounds bounds = val2.bounds;
			ManualLogSource log3 = Log;
			BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(31, 4, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("loaded ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Path.GetFileName(text));
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(": ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(val2.vertexCount);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" verts, ");
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("size ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Fmt(((Bounds)(ref bounds)).size));
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(", center ");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Fmt(((Bounds)(ref bounds)).center));
			}
			log3.LogInfo(val3);
			return true;
		}

		private static string ResolveModelPath(string file)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			if (string.IsNullOrEmpty(file))
			{
				return null;
			}
			if (Path.IsPathRooted(file))
			{
				if (!File.Exists(file))
				{
					return null;
				}
				return file;
			}
			string directoryName = Path.GetDirectoryName(typeof(NoseSwapper).Assembly.Location);
			if (!string.IsNullOrEmpty(directoryName))
			{
				string text = Path.Combine(directoryName, file);
				if (File.Exists(text))
				{
					return text;
				}
			}
			try
			{
				string pluginPath = Paths.PluginPath;
				if (!string.IsNullOrEmpty(pluginPath) && Directory.Exists(pluginPath))
				{
					string[] files = Directory.GetFiles(pluginPath, Path.GetFileName(file), SearchOption.AllDirectories);
					if (files.Length != 0)
					{
						return files[0];
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(36, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("search under plugins folder failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			return null;
		}

		public static void Apply(PlayerLips lips)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (lips == null || (Object)(object)_source == (Object)null)
			{
				return;
			}
			List<Renderer> list = FindNoseRenderers(lips);
			if (list.Count == 0)
			{
				Log.LogWarning((object)"no nose renderer found on this PlayerLips");
				return;
			}
			bool flag = default(bool);
			foreach (Renderer item in list)
			{
				Mesh mesh = GetMesh(item);
				if ((Object)(object)mesh == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)item).GetInstanceID();
				if (!Originals.ContainsKey(instanceID))
				{
					Originals[instanceID] = mesh;
					ManualLogSource log = Log;
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(50, 4, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("nose renderer '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)item).name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("': original mesh '");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)mesh).name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(mesh.vertexCount);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" verts, bounds ");
						Bounds bounds = mesh.bounds;
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Fmt(((Bounds)(ref bounds)).size));
					}
					log.LogInfo(val);
				}
				SetMesh(item, BuildFitted(Originals[instanceID], item));
			}
		}

		public static void RestoreAll()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			foreach (KeyValuePair<int, Mesh> original in Originals)
			{
				Renderer val = FindRendererById(original.Key);
				if ((Object)(object)val != (Object)null)
				{
					SetMesh(val, original.Value);
				}
			}
			ManualLogSource log = Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(32, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("restored ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(Originals.Count);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" original nose mesh(es)");
			}
			log.LogInfo(val2);
			Originals.Clear();
			Fitted.Clear();
		}

		private static List<Renderer> FindNoseRenderers(PlayerLips lips)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			List<Renderer> list = new List<Renderer>();
			bool flag = default(bool);
			try
			{
				Transform lipTransform = lips.lipTransform;
				if ((Object)(object)lipTransform != (Object)null)
				{
					Il2CppArrayBase<Renderer> componentsInChildren = ((Component)lipTransform).GetComponentsInChildren<Renderer>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						if ((Object)(object)componentsInChildren[i] != (Object)null)
						{
							list.Add(componentsInChildren[i]);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(28, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("lipTransform lookup failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				log.LogWarning(val);
			}
			if (list.Count > 0)
			{
				return list;
			}
			try
			{
				Il2CppReferenceArray<PropertyBlockHelper> propertyBlockHelpers = lips.propertyBlockHelpers;
				if (propertyBlockHelpers != null)
				{
					for (int j = 0; j < ((Il2CppArrayBase<PropertyBlockHelper>)(object)propertyBlockHelpers).Length; j++)
					{
						PropertyBlockHelper val2 = ((Il2CppArrayBase<PropertyBlockHelper>)(object)propertyBlockHelpers)[j];
						if ((Object)(object)val2 != (Object)null && (Object)(object)val2.targetRenderer != (Object)null)
						{
							list.Add(val2.targetRenderer);
						}
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Log;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(36, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("propertyBlockHelpers lookup failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex2.Message);
				}
				log2.LogWarning(val);
			}
			return list;
		}

		private static Renderer FindRendererById(int id)
		{
			foreach (Renderer item in Resources.FindObjectsOfTypeAll<Renderer>())
			{
				if ((Object)(object)item != (Object)null && ((Object)item).GetInstanceID() == id)
				{
					return item;
				}
			}
			return null;
		}

		private static Mesh GetMesh(Renderer r)
		{
			SkinnedMeshRenderer val = ((Il2CppObjectBase)r).TryCast<SkinnedMeshRenderer>();
			if ((Object)(object)val != (Object)null)
			{
				return val.sharedMesh;
			}
			MeshFilter component = ((Component)r).GetComponent<MeshFilter>();
			if (!((Object)(object)component != (Object)null))
			{
				return null;
			}
			return component.sharedMesh;
		}

		private static void SetMesh(Renderer r, Mesh mesh)
		{
			if ((Object)(object)mesh == (Object)null)
			{
				return;
			}
			SkinnedMeshRenderer val = ((Il2CppObjectBase)r).TryCast<SkinnedMeshRenderer>();
			if ((Object)(object)val != (Object)null)
			{
				val.sharedMesh = mesh;
				return;
			}
			MeshFilter component = ((Component)r).GetComponent<MeshFilter>();
			if ((Object)(object)component != (Object)null)
			{
				component.sharedMesh = mesh;
			}
		}

		private static Mesh BuildFitted(Mesh original, Renderer renderer)
		{
			//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_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_00c1: 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_00f9: 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_0103: 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_0124: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_004c: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Expected O, but got Unknown
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)original).GetInstanceID();
			if (Fitted.TryGetValue(instanceID, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Quaternion val = Quaternion.identity;
			Vector3 basePoint = Vector3.zero;
			float num = 1f;
			Bounds bounds;
			if (Plugin.AutoFit.Value)
			{
				Orient(original, out var dir, out basePoint, out var length);
				Vector3 val2 = ((Mathf.Abs(Vector3.Dot(dir, Vector3.up)) > 0.99f) ? Vector3.forward : Vector3.up);
				val = Quaternion.LookRotation(dir, val2);
				float num2 = length;
				bounds = _source.bounds;
				num = num2 / Mathf.Max(((Bounds)(ref bounds)).size.z, 0.0001f);
			}
			Vector3 val3 = new Vector3(Plugin.ScaleX.Value, Plugin.ScaleY.Value, Plugin.ScaleZ.Value) * (Plugin.Scale.Value * num);
			Quaternion val4 = val * Quaternion.Euler(Plugin.RotX.Value, Plugin.RotY.Value, Plugin.RotZ.Value);
			Vector3 val5 = basePoint + new Vector3(Plugin.OffsetX.Value, Plugin.OffsetY.Value, Plugin.OffsetZ.Value);
			Bounds bounds2 = _source.bounds;
			Matrix4x4 val6 = Matrix4x4.Translate(new Vector3(0f - ((Bounds)(ref bounds2)).center.x, 0f - ((Bounds)(ref bounds2)).center.y, 0f - ((Bounds)(ref bounds2)).min.z));
			Matrix4x4 val7 = Matrix4x4.TRS(val5, val4, val3) * val6;
			Mesh val8 = new Mesh
			{
				name = ((Object)_source).name + "_fitted",
				hideFlags = (HideFlags)61
			};
			Il2CppStructArray<Vector3> vertices = _source.vertices;
			Il2CppStructArray<Vector3> val9 = new Il2CppStructArray<Vector3>((long)((Il2CppArrayBase<Vector3>)(object)vertices).Length);
			for (int i = 0; i < ((Il2CppArrayBase<Vector3>)(object)vertices).Length; i++)
			{
				((Il2CppArrayBase<Vector3>)(object)val9)[i] = ((Matrix4x4)(ref val7)).MultiplyPoint3x4(((Il2CppArrayBase<Vector3>)(object)vertices)[i]);
			}
			val8.vertices = val9;
			Il2CppStructArray<Vector2> uv = _source.uv;
			if (uv != null && ((Il2CppArrayBase<Vector2>)(object)uv).Length == ((Il2CppArrayBase<Vector3>)(object)vertices).Length)
			{
				val8.uv = uv;
			}
			val8.triangles = _source.triangles;
			val8.RecalculateNormals();
			val8.RecalculateTangents();
			val8.RecalculateBounds();
			if ((Object)(object)((Il2CppObjectBase)renderer).TryCast<SkinnedMeshRenderer>() != (Object)null)
			{
				Log.LogWarning((object)("'" + ((Object)renderer).name + "' is a SkinnedMeshRenderer; the replacement has no bone weights and may not deform correctly."));
			}
			Fitted[instanceID] = val8;
			ManualLogSource log = Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val10 = new BepInExInfoLogInterpolatedStringHandler(41, 5, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val10).AppendLiteral("fitted '");
				((BepInExLogInterpolatedStringHandler)val10).AppendFormatted<string>(((Object)original).name);
				((BepInExLogInterpolatedStringHandler)val10).AppendLiteral("': scale ");
				((BepInExLogInterpolatedStringHandler)val10).AppendFormatted<string>(Fmt(val3));
				((BepInExLogInterpolatedStringHandler)val10).AppendLiteral(", base ");
				((BepInExLogInterpolatedStringHandler)val10).AppendFormatted<string>(Fmt(val5));
				((BepInExLogInterpolatedStringHandler)val10).AppendLiteral(", ");
				((BepInExLogInterpolatedStringHandler)val10).AppendLiteral("bounds ");
				bounds = val8.bounds;
				((BepInExLogInterpolatedStringHandler)val10).AppendFormatted<string>(Fmt(((Bounds)(ref bounds)).size));
				((BepInExLogInterpolatedStringHandler)val10).AppendLiteral(" center ");
				bounds = val8.bounds;
				((BepInExLogInterpolatedStringHandler)val10).AppendFormatted<string>(Fmt(((Bounds)(ref bounds)).center));
			}
			log.LogInfo(val10);
			return val8;
		}

		private static void Orient(Mesh original, out Vector3 dir, out Vector3 basePoint, out float length)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_005a: 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_0045: 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_00db: 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_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: 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_023d: 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_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Expected O, but got Unknown
			Bounds bounds = original.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			int num = 2;
			if (size.x >= size.y && size.x >= size.z)
			{
				num = 0;
			}
			else if (size.y >= size.x && size.y >= size.z)
			{
				num = 1;
			}
			length = Comp(size, num);
			float num2 = Comp(((Bounds)(ref bounds)).center, num);
			float num3 = num2 - length * 0.5f;
			float num4 = num2 + length * 0.5f;
			int i = (num + 1) % 3;
			int i2 = (num + 2) % 3;
			float num5 = length * 0.2f;
			double num6 = 0.0;
			double num7 = 0.0;
			int num8 = 0;
			int num9 = 0;
			Il2CppStructArray<Vector3> vertices = original.vertices;
			for (int j = 0; j < ((Il2CppArrayBase<Vector3>)(object)vertices).Length; j++)
			{
				Vector3 v = ((Il2CppArrayBase<Vector3>)(object)vertices)[j];
				float num10 = Comp(v, num);
				float num11 = Comp(v, i) - Comp(((Bounds)(ref bounds)).center, i);
				float num12 = Comp(v, i2) - Comp(((Bounds)(ref bounds)).center, i2);
				float num13 = Mathf.Sqrt(num11 * num11 + num12 * num12);
				if (num10 <= num3 + num5)
				{
					num6 += (double)num13;
					num8++;
				}
				else if (num10 >= num4 - num5)
				{
					num7 += (double)num13;
					num9++;
				}
			}
			bool flag;
			string text;
			if (num8 > 0 && num9 > 0)
			{
				float num14 = (float)(num6 / (double)num8);
				float num15 = (float)(num7 / (double)num9);
				flag = num15 < num14;
				text = $"vertex spread ({num14:0.####} lo vs {num15:0.####} hi)";
			}
			else
			{
				flag = Mathf.Abs(num4) > Mathf.Abs(num3);
				text = $"pivot offset (origin {Mathf.Abs(num3):0.###} from lo, {Mathf.Abs(num4):0.###} from hi; " + $"mesh not readable={!original.isReadable})";
			}
			if (Plugin.FlipDirection.Value)
			{
				flag = !flag;
				text += " [flipped by config]";
			}
			Vector3 val = (Vector3)(num switch
			{
				1 => Vector3.up, 
				0 => Vector3.right, 
				_ => Vector3.forward, 
			});
			dir = (flag ? val : (-val));
			basePoint = ((Bounds)(ref bounds)).center;
			basePoint = WithComp(basePoint, num, flag ? num3 : num4);
			ManualLogSource log = Log;
			bool flag2 = default(bool);
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(40, 5, ref flag2);
			if (flag2)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("oriented '");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(((Object)original).name);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("': axis ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<char>("XYZ"[num]);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", length ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<float>(length, "0.###");
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", ");
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("tip at ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(flag ? "max" : "min");
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" by ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
			}
			log.LogInfo(val2);
		}

		private static float Comp(Vector3 v, int i)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return i switch
			{
				1 => v.y, 
				0 => v.x, 
				_ => v.z, 
			};
		}

		private static Vector3 WithComp(Vector3 v, int i, float value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			switch (i)
			{
			case 0:
				v.x = value;
				break;
			case 1:
				v.y = value;
				break;
			default:
				v.z = value;
				break;
			}
			return v;
		}

		public static void Dump(PlayerLips lips)
		{
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_006b: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			bool flag = default(bool);
			try
			{
				Log.LogInfo((object)"---- nose hierarchy dump ----");
				Transform lipTransform = lips.lipTransform;
				if ((Object)(object)lipTransform == (Object)null)
				{
					Log.LogInfo((object)"lipTransform is null");
					return;
				}
				ManualLogSource log = Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(49, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("lipTransform '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)lipTransform).name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' localPos ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Fmt(lipTransform.localPosition));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("localScale ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Fmt(lipTransform.localScale));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" localEuler ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Fmt(lipTransform.localEulerAngles));
				}
				log.LogInfo(val);
				Transform parent = lipTransform.parent;
				ManualLogSource log2 = Log;
				val = new BepInExInfoLogInterpolatedStringHandler(14, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("parent chain: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)(object)parent != (Object)null) ? PathOf(parent) : "(none)");
				}
				log2.LogInfo(val);
				DumpTransform(lipTransform, 0);
				Il2CppReferenceArray<PropertyBlockHelper> propertyBlockHelpers = lips.propertyBlockHelpers;
				ManualLogSource log3 = Log;
				val = new BepInExInfoLogInterpolatedStringHandler(22, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("propertyBlockHelpers: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(((Il2CppArrayBase<PropertyBlockHelper>)(object)propertyBlockHelpers)?.Length ?? 0);
				}
				log3.LogInfo(val);
				if (propertyBlockHelpers != null)
				{
					for (int i = 0; i < ((Il2CppArrayBase<PropertyBlockHelper>)(object)propertyBlockHelpers).Length; i++)
					{
						PropertyBlockHelper obj = ((Il2CppArrayBase<PropertyBlockHelper>)(object)propertyBlockHelpers)[i];
						Renderer val2 = ((obj != null) ? obj.targetRenderer : null);
						ManualLogSource log4 = Log;
						val = new BepInExInfoLogInterpolatedStringHandler(22, 2, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("  [");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(i);
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] targetRenderer = ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)(object)val2 != (Object)null) ? PathOf(((Component)val2).transform) : "null");
						}
						log4.LogInfo(val);
					}
				}
				Log.LogInfo((object)"---- end dump ----");
			}
			catch (Exception ex)
			{
				ManualLogSource log5 = Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(13, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("dump failed: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex);
				}
				log5.LogError(val3);
			}
		}

		private static void DumpTransform(Transform t, int depth)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			string text = new string(' ', depth * 2);
			Renderer component = ((Component)t).GetComponent<Renderer>();
			string text2 = "";
			if ((Object)(object)component != (Object)null)
			{
				Mesh mesh = GetMesh(component);
				string name = ((MemberInfo)((Object)component).GetIl2CppType()).Name;
				object obj;
				if (!((Object)(object)mesh != (Object)null))
				{
					obj = "none";
				}
				else
				{
					object[] obj2 = new object[4]
					{
						((Object)mesh).name,
						mesh.vertexCount,
						null,
						null
					};
					Bounds bounds = mesh.bounds;
					obj2[2] = Fmt(((Bounds)(ref bounds)).size);
					bounds = mesh.bounds;
					obj2[3] = Fmt(((Bounds)(ref bounds)).center);
					obj = string.Format("'{0}' verts={1} bounds={2} center={3}", obj2);
				}
				text2 = "  [" + name + "] mesh=" + (string?)obj;
			}
			ManualLogSource log = Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(0, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)t).name);
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text2);
			}
			log.LogInfo(val);
			for (int i = 0; i < t.childCount; i++)
			{
				DumpTransform(t.GetChild(i), depth + 1);
			}
		}

		private static string PathOf(Transform t)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static string Fmt(Vector3 v)
		{
			//IL_0005: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({v.x:0.###}, {v.y:0.###}, {v.z:0.###})";
		}
	}
	internal static class ObjMesh
	{
		private static readonly char[] Sep = new char[2] { ' ', '\t' };

		public static Mesh Load(string path, bool invert, out string error)
		{
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			//IL_021b: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			error = null;
			try
			{
				List<Vector3> list = new List<Vector3>();
				List<Vector2> list2 = new List<Vector2>();
				Dictionary<string, int> remap = new Dictionary<string, int>();
				List<Vector3> list3 = new List<Vector3>();
				List<Vector2> list4 = new List<Vector2>();
				List<int> list5 = new List<int>();
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length == 0 || text[0] == '#')
					{
						continue;
					}
					string[] array2 = text.Split(Sep, StringSplitOptions.RemoveEmptyEntries);
					if (array2.Length == 0)
					{
						continue;
					}
					switch (array2[0])
					{
					case "v":
						if (array2.Length >= 4)
						{
							list.Add(new Vector3(0f - F(array2[1]), F(array2[2]), F(array2[3])));
						}
						break;
					case "vt":
						if (array2.Length >= 3)
						{
							list2.Add(new Vector2(F(array2[1]), F(array2[2])));
						}
						break;
					case "f":
					{
						if (array2.Length < 4)
						{
							break;
						}
						int[] array3 = new int[array2.Length - 1];
						for (int j = 1; j < array2.Length; j++)
						{
							array3[j - 1] = Corner(array2[j], list, list2, remap, list3, list4);
						}
						for (int k = 1; k < array3.Length - 1; k++)
						{
							list5.Add(array3[0]);
							if (invert)
							{
								list5.Add(array3[k]);
								list5.Add(array3[k + 1]);
							}
							else
							{
								list5.Add(array3[k + 1]);
								list5.Add(array3[k]);
							}
						}
						break;
					}
					}
				}
				if (list3.Count == 0 || list5.Count == 0)
				{
					error = "no geometry found in " + Path.GetFileName(path);
					return null;
				}
				Mesh val = new Mesh
				{
					name = "RealisticNose_" + Path.GetFileNameWithoutExtension(path)
				};
				Il2CppStructArray<Vector3> val2 = new Il2CppStructArray<Vector3>((long)list3.Count);
				for (int l = 0; l < list3.Count; l++)
				{
					((Il2CppArrayBase<Vector3>)(object)val2)[l] = list3[l];
				}
				val.vertices = val2;
				if (list4.Count == list3.Count)
				{
					Il2CppStructArray<Vector2> val3 = new Il2CppStructArray<Vector2>((long)list4.Count);
					for (int m = 0; m < list4.Count; m++)
					{
						((Il2CppArrayBase<Vector2>)(object)val3)[m] = list4[m];
					}
					val.uv = val3;
				}
				Il2CppStructArray<int> val4 = new Il2CppStructArray<int>((long)list5.Count);
				for (int n = 0; n < list5.Count; n++)
				{
					((Il2CppArrayBase<int>)(object)val4)[n] = list5[n];
				}
				val.triangles = val4;
				val.RecalculateNormals();
				val.RecalculateTangents();
				val.RecalculateBounds();
				return val;
			}
			catch (Exception ex)
			{
				error = ex.Message;
				return null;
			}
		}

		private static int Corner(string token, List<Vector3> positions, List<Vector2> texcoords, Dictionary<string, int> remap, List<Vector3> verts, List<Vector2> uvs)
		{
			//IL_0058: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (remap.TryGetValue(token, out var value))
			{
				return value;
			}
			string[] array = token.Split('/');
			int num = Index(array[0], positions.Count);
			int num2 = ((array.Length > 1 && array[1].Length > 0) ? Index(array[1], texcoords.Count) : (-1));
			verts.Add((num >= 0) ? positions[num] : Vector3.zero);
			uvs.Add((num2 >= 0) ? texcoords[num2] : Vector2.zero);
			return remap[token] = verts.Count - 1;
		}

		private static int Index(string s, int count)
		{
			if (!int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return -1;
			}
			if (result > 0)
			{
				return result - 1;
			}
			if (result < 0)
			{
				return count + result;
			}
			return -1;
		}

		private static float F(string s)
		{
			if (!float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return 0f;
			}
			return result;
		}
	}
	[BepInPlugin("deck.bigwalk.realisticnose", "Binus", "1.0.1")]
	public class Plugin : BasePlugin
	{
		public const string Guid = "deck.bigwalk.realisticnose";

		public static ManualLogSource Log;

		public static ConfigEntry<bool> Enabled;

		public static ConfigEntry<string> ObjFile;

		public static ConfigEntry<bool> AutoFit;

		public static ConfigEntry<bool> FlipDirection;

		public static ConfigEntry<bool> InvertFaces;

		public static ConfigEntry<float> Scale;

		public static ConfigEntry<float> ScaleX;

		public static ConfigEntry<float> ScaleY;

		public static ConfigEntry<float> ScaleZ;

		public static ConfigEntry<float> RotX;

		public static ConfigEntry<float> RotY;

		public static ConfigEntry<float> RotZ;

		public static ConfigEntry<float> OffsetX;

		public static ConfigEntry<float> OffsetY;

		public static ConfigEntry<float> OffsetZ;

		public static ConfigEntry<bool> DumpHierarchy;

		public override void Load()
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: 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_0282: Expected O, but got Unknown
			Log = ((BasePlugin)this).Log;
			Enabled = ((BasePlugin)this).Config.Bind<bool>("General", "Enabled", true, "Replace the character's nose mesh.");
			ObjFile = ((BasePlugin)this).Config.Bind<string>("General", "ObjFile", "binus2.obj", "Wavefront .obj to load. Looked for next to this plugin, then anywhere under BepInEx/plugins; an absolute path also works. Drop in your own model here.");
			AutoFit = ((BasePlugin)this).Config.Bind<bool>("Fit", "AutoFit", true, "Scale the model to match the size of the nose mesh it replaces. Turn off to size it purely with the Scale values below.");
			InvertFaces = ((BasePlugin)this).Config.Bind<bool>("Model", "InvertFaces", false, "Reverse triangle winding. Turn on if the model renders inside out - you see through the near surface and only the far side is visible.");
			FlipDirection = ((BasePlugin)this).Config.Bind<bool>("Fit", "FlipDirection", true, "Turn off if the nose points into the head instead of out of the face. Flips it end for end and re-anchors it, which RotationY=180 alone would not do. On by default because Big Walk's nose mesh has its pivot at the tip.");
			Scale = ((BasePlugin)this).Config.Bind<float>("Fit", "Scale", 1f, new ConfigDescription("Overall size multiplier, applied on top of AutoFit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 20f), Array.Empty<object>()));
			ScaleX = ((BasePlugin)this).Config.Bind<float>("Fit", "ScaleX", 1f, "Per-axis width multiplier.");
			ScaleY = ((BasePlugin)this).Config.Bind<float>("Fit", "ScaleY", 1f, "Per-axis height multiplier.");
			ScaleZ = ((BasePlugin)this).Config.Bind<float>("Fit", "ScaleZ", 1f, "Per-axis length multiplier.");
			RotX = ((BasePlugin)this).Config.Bind<float>("Fit", "RotationX", 0f, "Degrees, relative to the fitted orientation. The model should point along +Z.");
			RotY = ((BasePlugin)this).Config.Bind<float>("Fit", "RotationY", 0f, "Degrees.");
			RotZ = ((BasePlugin)this).Config.Bind<float>("Fit", "RotationZ", -90f, "Degrees of roll about the nose's own axis. -90 by default because Big Walk's nose bone does not use +Y as up; change this if your model sits rolled.");
			OffsetX = ((BasePlugin)this).Config.Bind<float>("Fit", "OffsetX", 0f, "Local-space nudge.");
			OffsetY = ((BasePlugin)this).Config.Bind<float>("Fit", "OffsetY", 0f, "Local-space nudge.");
			OffsetZ = ((BasePlugin)this).Config.Bind<float>("Fit", "OffsetZ", 0f, "Local-space nudge.");
			DumpHierarchy = ((BasePlugin)this).Config.Bind<bool>("Debug", "DumpHierarchy", false, "Log the nose object hierarchy the first time a character spawns. Turn on and include BepInEx/LogOutput.log when reporting a problem.");
			Harmony.CreateAndPatchAll(typeof(NosePatches), "deck.bigwalk.realisticnose");
			ClassInjector.RegisterTypeInIl2Cpp<NoseRuntime>();
			GameObject val = new GameObject("BinusRuntime")
			{
				hideFlags = (HideFlags)61
			};
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<NoseRuntime>();
			Log.LogInfo((object)"Binus loaded");
		}
	}
	[HarmonyPatch]
	internal static class NosePatches
	{
		private static bool _dumped;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerLips), "Initialize")]
		private static void OnLipsInitialized(PlayerLips __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			if (!Plugin.Enabled.Value)
			{
				return;
			}
			try
			{
				if (Plugin.DumpHierarchy.Value && !_dumped)
				{
					_dumped = true;
					NoseSwapper.Dump(__instance);
				}
				NoseRuntime.Queue(__instance);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(23, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("nose init hook failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
			}
		}
	}
	public class NoseRuntime : MonoBehaviour
	{
		private static readonly List<PlayerLips> Pending = new List<PlayerLips>();

		private bool _loaded;

		private float _nextSweep;

		public NoseRuntime(IntPtr ptr)
			: base(ptr)
		{
		}

		public static void Queue(PlayerLips lips)
		{
			lock (Pending)
			{
				Pending.Add(lips);
			}
		}

		private void Update()
		{
			if (!_loaded)
			{
				_loaded = true;
				NoseSwapper.LoadModel();
			}
			if (Pending.Count > 0)
			{
				PlayerLips[] array;
				lock (Pending)
				{
					array = Pending.ToArray();
					Pending.Clear();
				}
				PlayerLips[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					SafeApply(array2[i]);
				}
			}
			if (Time.unscaledTime >= _nextSweep)
			{
				_nextSweep = Time.unscaledTime + 3f;
				SweepNow();
			}
		}

		private static void SweepNow()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			if (!Plugin.Enabled.Value)
			{
				return;
			}
			try
			{
				List<PlayerCharacter> allPlayerCharacters = PlayerCharacter.allPlayerCharacters;
				if (allPlayerCharacters == null)
				{
					return;
				}
				for (int i = 0; i < allPlayerCharacters.Count; i++)
				{
					PlayerCharacter val = allPlayerCharacters[i];
					if ((Object)(object)val != (Object)null && val.lips != null)
					{
						SafeApply(val.lips);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(19, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("nose sweep failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
				}
				log.LogError(val2);
			}
		}

		private static void SafeApply(PlayerLips lips)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			try
			{
				NoseSwapper.Apply(lips);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(18, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("nose swap failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
			}
		}
	}
}