using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Data;
using ExpandWorld.Prefab;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Service;
using Splatform;
using Steamworks;
using UnityEngine;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ExpandWorldPrefabs")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a60e9e1f1ca7a28dc3e77f774fb30cf6e4872672")]
[assembly: AssemblyProduct("ExpandWorldPrefabs")]
[assembly: AssemblyTitle("ExpandWorldPrefabs")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 Data
{
	public class Calculator
	{
		public static Vector3 EvaluateVector3(string expression)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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)
			Vector3 zero = Vector3.zero;
			string[] array = Parse.Split(expression);
			zero.x = EvaluateFloat(array[0]).GetValueOrDefault();
			if (array.Length > 1)
			{
				zero.z = EvaluateFloat(array[1]).GetValueOrDefault();
			}
			if (array.Length > 2)
			{
				zero.y = EvaluateFloat(array[2]).GetValueOrDefault();
			}
			return zero;
		}

		public static Vector3 EvaluateVector3(string[] s, int index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			if (s.Length > index)
			{
				zero.x = EvaluateFloat(s[index]).GetValueOrDefault();
			}
			if (s.Length > index + 1)
			{
				zero.z = EvaluateFloat(s[index + 1]).GetValueOrDefault();
			}
			if (s.Length > index + 2)
			{
				zero.y = EvaluateFloat(s[index + 2]).GetValueOrDefault();
			}
			return zero;
		}

		public static Quaternion EvaluateQuaternion(string expression)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			string[] array = Parse.Split(expression);
			zero.y = EvaluateFloat(array[0]).GetValueOrDefault();
			if (array.Length > 1)
			{
				zero.x = EvaluateFloat(array[1]).GetValueOrDefault();
			}
			if (array.Length > 2)
			{
				zero.z = EvaluateFloat(array[2]).GetValueOrDefault();
			}
			return Quaternion.Euler(zero);
		}

		public static Quaternion EvaluateQuaternion(string[] s, int index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			if (s.Length > index)
			{
				zero.y = EvaluateFloat(s[index]).GetValueOrDefault();
			}
			if (s.Length > index + 1)
			{
				zero.x = EvaluateFloat(s[index + 1]).GetValueOrDefault();
			}
			if (s.Length > index + 2)
			{
				zero.z = EvaluateFloat(s[index + 2]).GetValueOrDefault();
			}
			return Quaternion.Euler(zero);
		}

		public static int? EvaluateInt(string expression)
		{
			try
			{
				return (int?)EvaluateLong(expression);
			}
			catch
			{
				return null;
			}
		}

		public static float? EvaluateFloat(string expression)
		{
			try
			{
				return (float)EvaluateDouble(expression);
			}
			catch
			{
				return null;
			}
		}

		private static double EvaluateDouble(string expression)
		{
			string[] array = expression.Split(new char[1] { '+' });
			if (array.Length > 1)
			{
				double num = 0.0;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num += EvaluateDouble(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '-' });
			if (array3.Where((string s) => s != "").Count() > 1)
			{
				double? num2 = null;
				for (int j = 0; j < array3.Length; j++)
				{
					if (!(array3[j] == "") || j + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvaluateDouble(array3[j])) : new double?(EvaluateDouble(array3[j])));
					}
					else
					{
						array3[j + 1] = "-" + array3[j + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				double num3 = 1.0;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 *= EvaluateDouble(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				double num4 = EvaluateDouble(array5[0]);
				for (int k = 1; k < array5.Length; k++)
				{
					num4 /= EvaluateDouble(array5[k]);
				}
				return num4;
			}
			try
			{
				return double.Parse(expression.Trim(), NumberFormatInfo.InvariantInfo);
			}
			catch
			{
				throw new InvalidOperationException("Failed to parse expression: " + expression);
			}
		}

		public static long? EvaluateLong(string expression)
		{
			try
			{
				return EvalLong(expression);
			}
			catch
			{
				return null;
			}
		}

		private static long EvalLong(string expression)
		{
			string[] array = expression.Split(new char[1] { '+' });
			if (array.Length > 1)
			{
				long num = 0L;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num += EvalLong(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '-' });
			if (array3.Where((string s) => s != "").Count() > 1)
			{
				long? num2 = null;
				for (int j = 0; j < array3.Length; j++)
				{
					if (!(array3[j] == "") || j + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvalLong(array3[j])) : new long?(EvalLong(array3[j])));
					}
					else
					{
						array3[j + 1] = "-" + array3[j + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				long num3 = 1L;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 *= EvalLong(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				long num4 = EvalLong(array5[0]);
				for (int k = 1; k < array5.Length; k++)
				{
					num4 /= EvalLong(array5[k]);
				}
				return num4;
			}
			try
			{
				return long.Parse(expression.Trim());
			}
			catch
			{
				throw new InvalidOperationException("Failed to parse expression: " + expression);
			}
		}
	}
	public class DataData
	{
		[DefaultValue(null)]
		public string? name;

		[DefaultValue(null)]
		public string? position;

		[DefaultValue(null)]
		public string? rotation;

		[DefaultValue(null)]
		public string? connection;

		[DefaultValue(null)]
		public string[]? bools;

		[DefaultValue(null)]
		public string[]? ints;

		[DefaultValue(null)]
		public string[]? hashes;

		[DefaultValue(null)]
		public string[]? floats;

		[DefaultValue(null)]
		public string[]? strings;

		[DefaultValue(null)]
		public string[]? longs;

		[DefaultValue(null)]
		public string[]? vecs;

		[DefaultValue(null)]
		public string[]? quats;

		[DefaultValue(null)]
		public string[]? bytes;

		[DefaultValue(null)]
		public ItemData[]? items;

		[DefaultValue(null)]
		public string? containerSize;

		[DefaultValue(null)]
		public string? itemAmount;

		[DefaultValue(null)]
		public string? valueGroup;

		[DefaultValue(null)]
		public string? value;

		[DefaultValue(null)]
		public string[]? values;

		[DefaultValue(null)]
		public string? persistent;

		[DefaultValue(null)]
		public string? distant;

		[DefaultValue(null)]
		public string? priority;
	}
	public class ItemData
	{
		public string pos = "";

		[DefaultValue(1f)]
		public float chance = 1f;

		[DefaultValue("")]
		public string prefab = "";

		public string? stack;

		public string? quality;

		public string? variant;

		public string? durability;

		public string? crafterID;

		public string? crafterName;

		public string? worldLevel;

		public string? equipped;

		public string? pickedUp;

		public Dictionary<string, string>? customData;
	}
	public class DataEntry
	{
		public bool InjectDataByDefault;

		public Dictionary<int, IStringValue>? Strings;

		public Dictionary<int, IFloatValue>? Floats;

		public Dictionary<int, IIntValue>? Ints;

		public Dictionary<int, IIntValue>? Components;

		public Dictionary<int, IBoolValue>? Bools;

		public Dictionary<int, IHashValue>? Hashes;

		public Dictionary<int, ILongValue>? Longs;

		public Dictionary<int, IVector3Value>? Vecs;

		public Dictionary<int, IQuaternionValue>? Quats;

		public Dictionary<int, IBytesValue>? ByteArrays;

		public List<ItemValue>? Items;

		public Vector2i? ContainerSize;

		public IIntValue? ItemAmount;

		public ConnectionType? ConnectionType;

		public int ConnectionHash;

		public IZdoIdValue? OriginalId;

		public IZdoIdValue? TargetConnectionId;

		public IBoolValue? Persistent;

		public IBoolValue? Distant;

		public ObjectType? Priority;

		public IVector3Value? Position;

		public IQuaternionValue? Rotation;

		public static HashSet<string> SupportedTypes = new HashSet<string> { "float", "int", "bool", "hash", "long", "string", "vec", "vec3", "quat", "bytes" };

		public DataEntry()
		{
		}

		public DataEntry(string[] tkv)
		{
			InjectDataByDefault = true;
			Load(tkv);
		}

		public DataEntry(DataData data)
		{
			Load(data);
		}

		public DataEntry(ZDO zdo)
		{
			Load(zdo);
		}

		public DataEntry(ZPackage pkg)
		{
			Load(pkg);
		}

		public void Load(ZDO zdo)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			ZDOID uid = zdo.m_uid;
			Floats = (ZDOExtraData.s_floats.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, float>>)ZDOExtraData.s_floats[uid]).ToDictionary((KeyValuePair<int, float> kvp) => kvp.Key, (KeyValuePair<int, float> kvp) => DataValue.Simple(kvp.Value)) : null);
			Ints = (ZDOExtraData.s_ints.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, int>>)ZDOExtraData.s_ints[uid]).ToDictionary((KeyValuePair<int, int> kvp) => kvp.Key, (KeyValuePair<int, int> kvp) => DataValue.Simple(kvp.Value)) : null);
			Longs = (ZDOExtraData.s_longs.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, long>>)ZDOExtraData.s_longs[uid]).ToDictionary((KeyValuePair<int, long> kvp) => kvp.Key, (KeyValuePair<int, long> kvp) => DataValue.Simple(kvp.Value)) : null);
			Strings = (ZDOExtraData.s_strings.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, string>>)ZDOExtraData.s_strings[uid]).ToDictionary((KeyValuePair<int, string> kvp) => kvp.Key, (KeyValuePair<int, string> kvp) => DataValue.Simple(kvp.Value)) : null);
			Vecs = (ZDOExtraData.s_vec3.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, Vector3>>)ZDOExtraData.s_vec3[uid]).ToDictionary((KeyValuePair<int, Vector3> kvp) => kvp.Key, (KeyValuePair<int, Vector3> kvp) => DataValue.Simple(kvp.Value)) : null);
			Quats = (ZDOExtraData.s_quats.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, Quaternion>>)ZDOExtraData.s_quats[uid]).ToDictionary((KeyValuePair<int, Quaternion> kvp) => kvp.Key, (KeyValuePair<int, Quaternion> kvp) => DataValue.Simple(kvp.Value)) : null);
			ByteArrays = (ZDOExtraData.s_byteArrays.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, byte[]>>)ZDOExtraData.s_byteArrays[uid]).ToDictionary((KeyValuePair<int, byte[]> kvp) => kvp.Key, (KeyValuePair<int, byte[]> kvp) => DataValue.Simple(kvp.Value)) : null);
			if (ZDOExtraData.s_connectionsHashData.TryGetValue(uid, out var value))
			{
				ConnectionType = value.m_type;
				ConnectionHash = value.m_hash;
			}
			OriginalId = new SimpleZdoIdValue(uid);
			if (ZDOExtraData.s_connections.TryGetValue(uid, out var value2) && value2.m_target != ZDOID.None)
			{
				TargetConnectionId = new SimpleZdoIdValue(value2.m_target);
				ConnectionType = value2.m_type;
			}
			Persistent = null;
			Distant = null;
			Priority = null;
		}

		public void Load(DataEntry data)
		{
			if (data.Floats != null)
			{
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				foreach (KeyValuePair<int, IFloatValue> @float in data.Floats)
				{
					Floats[@float.Key] = @float.Value;
				}
			}
			if (data.Vecs != null)
			{
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				foreach (KeyValuePair<int, IVector3Value> vec in data.Vecs)
				{
					Vecs[vec.Key] = vec.Value;
				}
			}
			if (data.Quats != null)
			{
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				foreach (KeyValuePair<int, IQuaternionValue> quat in data.Quats)
				{
					Quats[quat.Key] = quat.Value;
				}
			}
			if (data.Ints != null)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				foreach (KeyValuePair<int, IIntValue> @int in data.Ints)
				{
					Ints[@int.Key] = @int.Value;
				}
			}
			if (data.Strings != null)
			{
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				foreach (KeyValuePair<int, IStringValue> @string in data.Strings)
				{
					Strings[@string.Key] = @string.Value;
				}
			}
			if (data.ByteArrays != null)
			{
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, IBytesValue>();
				}
				foreach (KeyValuePair<int, IBytesValue> byteArray in data.ByteArrays)
				{
					ByteArrays[byteArray.Key] = byteArray.Value;
				}
			}
			if (data.Longs != null)
			{
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				foreach (KeyValuePair<int, ILongValue> @long in data.Longs)
				{
					Longs[@long.Key] = @long.Value;
				}
			}
			if (data.Bools != null)
			{
				if (Bools == null)
				{
					Bools = new Dictionary<int, IBoolValue>();
				}
				foreach (KeyValuePair<int, IBoolValue> @bool in data.Bools)
				{
					Bools[@bool.Key] = @bool.Value;
				}
			}
			if (data.Hashes != null)
			{
				if (Hashes == null)
				{
					Hashes = new Dictionary<int, IHashValue>();
				}
				foreach (KeyValuePair<int, IHashValue> hash in data.Hashes)
				{
					Hashes[hash.Key] = hash.Value;
				}
			}
			if (data.Components != null)
			{
				if (Components == null)
				{
					Components = new Dictionary<int, IIntValue>();
				}
				foreach (KeyValuePair<int, IIntValue> component in data.Components)
				{
					Components[component.Key] = component.Value;
				}
			}
			if (data.Items != null)
			{
				if (Items == null)
				{
					Items = new List<ItemValue>();
				}
				foreach (ItemValue item in data.Items)
				{
					Items.Add(item);
				}
			}
			if (data.ContainerSize.HasValue)
			{
				ContainerSize = data.ContainerSize;
			}
			if (data.ItemAmount != null)
			{
				ItemAmount = data.ItemAmount;
			}
			ConnectionType = data.ConnectionType;
			ConnectionHash = data.ConnectionHash;
			OriginalId = data.OriginalId;
			TargetConnectionId = data.TargetConnectionId;
			if (data.Persistent != null)
			{
				Persistent = data.Persistent;
			}
			if (data.Distant != null)
			{
				Distant = data.Distant;
			}
			if (data.Priority.HasValue)
			{
				Priority = data.Priority;
			}
			if (data.Position != null)
			{
				Position = data.Position;
			}
			if (data.Rotation != null)
			{
				Rotation = data.Rotation;
			}
		}

		public DataEntry Reset(DataData data)
		{
			Floats = null;
			Vecs = null;
			Quats = null;
			Ints = null;
			Strings = null;
			ByteArrays = null;
			Longs = null;
			Bools = null;
			Hashes = null;
			Items = null;
			Components = null;
			ContainerSize = null;
			ItemAmount = null;
			ConnectionType = null;
			ConnectionHash = 0;
			OriginalId = null;
			TargetConnectionId = null;
			Position = null;
			Rotation = null;
			Distant = null;
			Persistent = null;
			Priority = null;
			Load(data);
			return this;
		}

		public void Load(DataData data)
		{
			//IL_0a29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb3: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>();
			if (data.floats != null)
			{
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				string[] floats = data.floats;
				foreach (string text in floats)
				{
					KeyValuePair<string, string> keyValuePair = Parse.Kvp(text);
					if (keyValuePair.Key == "")
					{
						throw new InvalidOperationException("Failed to parse float " + text + ".");
					}
					if (keyValuePair.Key.Contains("."))
					{
						hashSet.Add(keyValuePair.Key.Split(new char[1] { '.' })[0]);
					}
					int key = ZdoHelper.Hash(keyValuePair.Key);
					if (Floats.ContainsKey(key))
					{
						Log.Warning("Data " + data.name + ": Duplicate float key " + keyValuePair.Key + ".");
					}
					Floats[key] = DataValue.Float(keyValuePair.Value);
				}
			}
			if (data.ints != null)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				string[] floats = data.ints;
				foreach (string text2 in floats)
				{
					KeyValuePair<string, string> keyValuePair2 = Parse.Kvp(text2);
					if (keyValuePair2.Key == "")
					{
						throw new InvalidOperationException("Failed to parse int " + text2 + ".");
					}
					if (keyValuePair2.Key.Contains("."))
					{
						hashSet.Add(keyValuePair2.Key.Split(new char[1] { '.' })[0]);
					}
					int key2 = ZdoHelper.Hash(keyValuePair2.Key);
					if (Ints.ContainsKey(key2))
					{
						Log.Warning("Data " + data.name + ": Duplicate int key " + keyValuePair2.Key + ".");
					}
					Ints[key2] = DataValue.Int(keyValuePair2.Value);
				}
			}
			if (data.bools != null)
			{
				if (Bools == null)
				{
					Bools = new Dictionary<int, IBoolValue>();
				}
				string[] floats = data.bools;
				foreach (string text3 in floats)
				{
					KeyValuePair<string, string> keyValuePair3 = Parse.Kvp(text3);
					if (keyValuePair3.Key == "")
					{
						throw new InvalidOperationException("Failed to parse bool " + text3 + ".");
					}
					if (keyValuePair3.Key.Contains("."))
					{
						hashSet.Add(keyValuePair3.Key.Split(new char[1] { '.' })[0]);
					}
					int key3 = ZdoHelper.Hash(keyValuePair3.Key);
					if (Bools.ContainsKey(key3))
					{
						Log.Warning("Data " + data.name + ": Duplicate bool key " + keyValuePair3.Key + ".");
					}
					Bools[key3] = DataValue.Bool(keyValuePair3.Value);
				}
			}
			if (data.hashes != null)
			{
				if (Hashes == null)
				{
					Hashes = new Dictionary<int, IHashValue>();
				}
				string[] floats = data.hashes;
				foreach (string text4 in floats)
				{
					KeyValuePair<string, string> keyValuePair4 = Parse.Kvp(text4);
					if (keyValuePair4.Key == "")
					{
						throw new InvalidOperationException("Failed to parse hash " + text4 + ".");
					}
					if (keyValuePair4.Key.Contains("."))
					{
						hashSet.Add(keyValuePair4.Key.Split(new char[1] { '.' })[0]);
					}
					int key4 = ZdoHelper.Hash(keyValuePair4.Key);
					if (Hashes.ContainsKey(key4))
					{
						Log.Warning("Data " + data.name + ": Duplicate hash key " + keyValuePair4.Key + ".");
					}
					Hashes[key4] = DataValue.Hash(keyValuePair4.Value);
				}
			}
			if (data.longs != null)
			{
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				string[] floats = data.longs;
				foreach (string text5 in floats)
				{
					KeyValuePair<string, string> keyValuePair5 = Parse.Kvp(text5);
					if (keyValuePair5.Key == "")
					{
						throw new InvalidOperationException("Failed to parse long " + text5 + ".");
					}
					if (keyValuePair5.Key.Contains("."))
					{
						hashSet.Add(keyValuePair5.Key.Split(new char[1] { '.' })[0]);
					}
					int key5 = ZdoHelper.Hash(keyValuePair5.Key);
					if (Longs.ContainsKey(key5))
					{
						Log.Warning("Data " + data.name + ": Duplicate long key " + keyValuePair5.Key + ".");
					}
					Longs[key5] = DataValue.Long(keyValuePair5.Value);
				}
			}
			if (data.strings != null)
			{
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				string[] floats = data.strings;
				foreach (string text6 in floats)
				{
					KeyValuePair<string, string> keyValuePair6 = Parse.Kvp(text6);
					if (keyValuePair6.Key == "")
					{
						throw new InvalidOperationException("Failed to parse string " + text6 + ".");
					}
					if (keyValuePair6.Key.Contains("."))
					{
						hashSet.Add(keyValuePair6.Key.Split(new char[1] { '.' })[0]);
					}
					int key6 = ZdoHelper.Hash(keyValuePair6.Key);
					if (Strings.ContainsKey(key6))
					{
						Log.Warning("Data " + data.name + ": Duplicate string key " + keyValuePair6.Key + ".");
					}
					Strings[key6] = DataValue.String(keyValuePair6.Value);
				}
			}
			if (data.vecs != null)
			{
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				string[] floats = data.vecs;
				foreach (string text7 in floats)
				{
					KeyValuePair<string, string> keyValuePair7 = Parse.Kvp(text7);
					if (keyValuePair7.Key == "")
					{
						throw new InvalidOperationException("Failed to parse vector " + text7 + ".");
					}
					if (keyValuePair7.Key.Contains("."))
					{
						hashSet.Add(keyValuePair7.Key.Split(new char[1] { '.' })[0]);
					}
					int key7 = ZdoHelper.Hash(keyValuePair7.Key);
					if (Vecs.ContainsKey(key7))
					{
						Log.Warning("Data " + data.name + ": Duplicate vector key " + keyValuePair7.Key + ".");
					}
					Vecs[key7] = DataValue.Vector3(keyValuePair7.Value);
				}
			}
			if (data.quats != null)
			{
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				string[] floats = data.quats;
				foreach (string text8 in floats)
				{
					KeyValuePair<string, string> keyValuePair8 = Parse.Kvp(text8);
					if (keyValuePair8.Key == "")
					{
						throw new InvalidOperationException("Failed to parse quaternion " + text8 + ".");
					}
					if (keyValuePair8.Key.Contains("."))
					{
						hashSet.Add(keyValuePair8.Key.Split(new char[1] { '.' })[0]);
					}
					int key8 = ZdoHelper.Hash(keyValuePair8.Key);
					if (Quats.ContainsKey(key8))
					{
						Log.Warning("Data " + data.name + ": Duplicate quaternion key " + keyValuePair8.Key + ".");
					}
					Quats[key8] = DataValue.Quaternion(keyValuePair8.Value);
				}
			}
			if (data.bytes != null)
			{
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, IBytesValue>();
				}
				string[] floats = data.bytes;
				foreach (string text9 in floats)
				{
					KeyValuePair<string, string> keyValuePair9 = Parse.Kvp(text9);
					if (keyValuePair9.Key == "")
					{
						throw new InvalidOperationException("Failed to parse byte array " + text9 + ".");
					}
					if (keyValuePair9.Key.Contains("."))
					{
						hashSet.Add(keyValuePair9.Key.Split(new char[1] { '.' })[0]);
					}
					int key9 = ZdoHelper.Hash(keyValuePair9.Key);
					if (ByteArrays.ContainsKey(key9))
					{
						Log.Warning("Data " + data.name + ": Duplicate byte array key " + keyValuePair9.Key + ".");
					}
					ByteArrays[key9] = DataValue.Bytes(keyValuePair9.Value);
				}
			}
			if (data.items != null)
			{
				List<ItemValue> list = new List<ItemValue>();
				list.AddRange(data.items.Select((ItemData item) => new ItemValue(item)));
				Items = list;
			}
			if (!string.IsNullOrWhiteSpace(data.containerSize))
			{
				ContainerSize = Parse.Vector2Int(data.containerSize);
			}
			if (!string.IsNullOrWhiteSpace(data.itemAmount))
			{
				ItemAmount = DataValue.Int(data.itemAmount);
			}
			if (hashSet.Count > 0)
			{
				if (Components == null)
				{
					Components = new Dictionary<int, IIntValue>();
				}
				Components[ZdoHelper.Hash("HasFields")] = DataValue.Simple(1);
				foreach (string item in hashSet)
				{
					Components[ZdoHelper.Hash("HasFields" + item)] = DataValue.Simple(1);
				}
			}
			if (!string.IsNullOrWhiteSpace(data.position))
			{
				Position = DataValue.Vector3(data.position);
			}
			if (!string.IsNullOrWhiteSpace(data.rotation))
			{
				Rotation = DataValue.Quaternion(data.rotation);
			}
			if (data.persistent != null)
			{
				Persistent = DataValue.Bool(data.persistent);
			}
			if (data.distant != null)
			{
				Distant = DataValue.Bool(data.distant);
			}
			if (data.priority != null)
			{
				Priority = (Enum.TryParse<ObjectType>(data.priority, ignoreCase: true, out ObjectType result) ? new ObjectType?(result) : null);
			}
			if (string.IsNullOrWhiteSpace(data.connection))
			{
				return;
			}
			string[] array = Parse.SplitWithEmpty(data.connection);
			if (array.Length == 1)
			{
				string[] floats = array;
				List<string> list2 = new List<string>(floats.Length);
				list2.AddRange(floats);
				ConnectionType = ToByteEnum<ConnectionType>(list2);
				return;
			}
			List<string> list3 = array.Take(array.Length - 1).ToList();
			string text10 = array[^1];
			ConnectionType = ToByteEnum<ConnectionType>(list3);
			if (text10.Contains(":") || text10.Contains("<"))
			{
				TargetConnectionId = DataValue.ZdoId(text10);
				OriginalId = TargetConnectionId;
				return;
			}
			ConnectionHash = Parse.Int(text10);
			if (ConnectionHash == 0)
			{
				ConnectionHash = StringExtensionMethods.GetStableHashCode(text10);
			}
		}

		public void Load(string[] tkv)
		{
			if (tkv.Length != 3)
			{
				throw new InvalidOperationException("Failed to parse type, field, value.");
			}
			string text = tkv[0].ToLowerInvariant();
			string text2 = tkv[1];
			string values = tkv[2];
			if (text2.Contains("."))
			{
				string text3 = text2.Split(new char[1] { '.' })[0];
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				Ints[ZdoHelper.Hash("HasFields")] = DataValue.Simple(1);
				Ints[ZdoHelper.Hash("HasFields" + text3)] = DataValue.Simple(1);
			}
			switch (text)
			{
			case "float":
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				Floats[ZdoHelper.Hash(text2)] = DataValue.Float(values);
				break;
			case "int":
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				Ints[ZdoHelper.Hash(text2)] = DataValue.Int(values);
				break;
			case "bool":
				if (Bools == null)
				{
					Bools = new Dictionary<int, IBoolValue>();
				}
				Bools[ZdoHelper.Hash(text2)] = DataValue.Bool(values);
				break;
			case "hash":
				if (Hashes == null)
				{
					Hashes = new Dictionary<int, IHashValue>();
				}
				Hashes[ZdoHelper.Hash(text2)] = DataValue.Hash(values);
				break;
			case "long":
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				Longs[ZdoHelper.Hash(text2)] = DataValue.Long(values);
				break;
			case "string":
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				Strings[ZdoHelper.Hash(text2)] = DataValue.String(values);
				break;
			case "vec":
			case "vec3":
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				Vecs[ZdoHelper.Hash(text2)] = DataValue.Vector3(values);
				break;
			case "quat":
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				Quats[ZdoHelper.Hash(text2)] = DataValue.Quaternion(values);
				break;
			case "bytes":
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, IBytesValue>();
				}
				ByteArrays[ZdoHelper.Hash(text2)] = DataValue.Bytes(values);
				break;
			default:
				throw new InvalidOperationException("Unknown type " + text + ".");
			}
		}

		public void Load(ZPackage pkg)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			pkg.SetPos(0);
			int num = pkg.ReadInt();
			if (((uint)num & (true ? 1u : 0u)) != 0)
			{
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				byte b = pkg.ReadByte();
				for (int i = 0; i < b; i++)
				{
					Floats[pkg.ReadInt()] = new SimpleFloatValue(pkg.ReadSingle());
				}
			}
			if (((uint)num & 2u) != 0)
			{
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				byte b2 = pkg.ReadByte();
				for (int j = 0; j < b2; j++)
				{
					Vecs[pkg.ReadInt()] = new SimpleVector3Value(pkg.ReadVector3());
				}
			}
			if (((uint)num & 4u) != 0)
			{
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				byte b3 = pkg.ReadByte();
				for (int k = 0; k < b3; k++)
				{
					Quats[pkg.ReadInt()] = new SimpleQuaternionValue(pkg.ReadQuaternion());
				}
			}
			if (((uint)num & 8u) != 0)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				byte b4 = pkg.ReadByte();
				for (int l = 0; l < b4; l++)
				{
					Ints[pkg.ReadInt()] = new SimpleIntValue(pkg.ReadInt());
				}
			}
			if (((uint)num & 0x40u) != 0)
			{
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				byte b5 = pkg.ReadByte();
				for (int m = 0; m < b5; m++)
				{
					Longs[pkg.ReadInt()] = new SimpleLongValue(pkg.ReadLong());
				}
			}
			if (((uint)num & 0x10u) != 0)
			{
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				byte b6 = pkg.ReadByte();
				for (int n = 0; n < b6; n++)
				{
					Strings[pkg.ReadInt()] = new SimpleStringValue(pkg.ReadString());
				}
			}
			if (((uint)num & 0x80u) != 0)
			{
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, IBytesValue>();
				}
				byte b7 = pkg.ReadByte();
				for (int num2 = 0; num2 < b7; num2++)
				{
					ByteArrays[pkg.ReadInt()] = new SimpleBytesValue(pkg.ReadByteArray());
				}
			}
			if (((uint)num & 0x100u) != 0)
			{
				ConnectionType = (ConnectionType)pkg.ReadByte();
				ConnectionHash = pkg.ReadInt();
			}
			if (((uint)num & 0x200u) != 0)
			{
				Persistent = new SimpleBoolValue(pkg.ReadBool());
			}
			if (((uint)num & 0x400u) != 0)
			{
				Distant = new SimpleBoolValue(pkg.ReadBool());
			}
			if (((uint)num & 0x800u) != 0)
			{
				Priority = (ObjectType)pkg.ReadByte();
			}
		}

		public bool Match(Parameters pars, ZDO zdo)
		{
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: 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_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: 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_02e4: Unknown result type (might be due to invalid IL or missing references)
			Parameters pars2 = pars;
			ZDO zdo2 = zdo;
			if (Strings != null && Strings.Any<KeyValuePair<int, IStringValue>>((KeyValuePair<int, IStringValue> pair) => pair.Value.Match(pars2, GetString(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Floats != null && Floats.Any<KeyValuePair<int, IFloatValue>>((KeyValuePair<int, IFloatValue> pair) => pair.Value.Match(pars2, GetFloat(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Ints != null && Ints.Any<KeyValuePair<int, IIntValue>>((KeyValuePair<int, IIntValue> pair) => pair.Value.Match(pars2, GetInt(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Longs != null && Longs.Any<KeyValuePair<int, ILongValue>>((KeyValuePair<int, ILongValue> pair) => pair.Value.Match(pars2, GetLong(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Bools != null && Bools.Any<KeyValuePair<int, IBoolValue>>((KeyValuePair<int, IBoolValue> pair) => pair.Value.Match(pars2, GetBool(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Hashes != null && Hashes.Any<KeyValuePair<int, IHashValue>>((KeyValuePair<int, IHashValue> pair) => pair.Value.Match(pars2, GetInt(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Vecs != null && Vecs.Any<KeyValuePair<int, IVector3Value>>((KeyValuePair<int, IVector3Value> pair) => pair.Value.Match(pars2, GetVec(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (Quats != null && Quats.Any<KeyValuePair<int, IQuaternionValue>>((KeyValuePair<int, IQuaternionValue> pair) => pair.Value.Match(pars2, GetQuaternion(zdo2, pair.Key)) == false))
			{
				return false;
			}
			if (ByteArrays != null && ByteArrays.Any<KeyValuePair<int, IBytesValue>>((KeyValuePair<int, IBytesValue> pair) => pair.Value.Match(pars2, zdo2.GetByteArray(pair.Key, (byte[])null)) == false))
			{
				return false;
			}
			if (Persistent != null && Persistent.Match(pars2, zdo2.Persistent) == false)
			{
				return false;
			}
			if (Distant != null && Distant.Match(pars2, zdo2.Distant) == false)
			{
				return false;
			}
			if (Priority.HasValue && Priority.Value != zdo2.Type)
			{
				return false;
			}
			if (Items != null)
			{
				return ItemValue.Match(pars2, Items, zdo2, ItemAmount);
			}
			if (ItemAmount != null)
			{
				return ItemValue.Match(pars2, zdo2, ItemAmount);
			}
			if (ConnectionType.HasValue)
			{
				if ((int)ConnectionType.Value == 0)
				{
					ZDOConnection connection = zdo2.GetConnection();
					if (connection != null && connection.m_target != ZDOID.None)
					{
						return false;
					}
				}
				else
				{
					ZDOID connectionZDOID = zdo2.GetConnectionZDOID(ConnectionType.Value);
					if (TargetConnectionId == null)
					{
						if (connectionZDOID == ZDOID.None)
						{
							return false;
						}
					}
					else
					{
						ZDOID? val = TargetConnectionId.Get(pars2);
						if (val.HasValue)
						{
							ZDOID val2 = connectionZDOID;
							ZDOID? val3 = val;
							if (!val3.HasValue || val2 != val3.GetValueOrDefault())
							{
								return false;
							}
						}
					}
				}
			}
			return true;
		}

		public bool Unmatch(Parameters pars, ZDO zdo)
		{
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: 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_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_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			Parameters pars2 = pars;
			ZDO zdo2 = zdo;
			if (Strings != null && Strings.Any<KeyValuePair<int, IStringValue>>((KeyValuePair<int, IStringValue> pair) => pair.Value.Match(pars2, GetString(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Floats != null && Floats.Any<KeyValuePair<int, IFloatValue>>((KeyValuePair<int, IFloatValue> pair) => pair.Value.Match(pars2, GetFloat(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Ints != null && Ints.Any<KeyValuePair<int, IIntValue>>((KeyValuePair<int, IIntValue> pair) => pair.Value.Match(pars2, GetInt(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Longs != null && Longs.Any<KeyValuePair<int, ILongValue>>((KeyValuePair<int, ILongValue> pair) => pair.Value.Match(pars2, GetLong(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Bools != null && Bools.Any<KeyValuePair<int, IBoolValue>>((KeyValuePair<int, IBoolValue> pair) => pair.Value.Match(pars2, GetBool(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Hashes != null && Hashes.Any<KeyValuePair<int, IHashValue>>((KeyValuePair<int, IHashValue> pair) => pair.Value.Match(pars2, GetInt(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Vecs != null && Vecs.Any<KeyValuePair<int, IVector3Value>>((KeyValuePair<int, IVector3Value> pair) => pair.Value.Match(pars2, GetVec(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (Quats != null && Quats.Any<KeyValuePair<int, IQuaternionValue>>((KeyValuePair<int, IQuaternionValue> pair) => pair.Value.Match(pars2, GetQuaternion(zdo2, pair.Key)).GetValueOrDefault()))
			{
				return false;
			}
			if (ByteArrays != null && ByteArrays.Any<KeyValuePair<int, IBytesValue>>((KeyValuePair<int, IBytesValue> pair) => pair.Value.Match(pars2, zdo2.GetByteArray(pair.Key, (byte[])null)).GetValueOrDefault()))
			{
				return false;
			}
			if (Persistent != null && Persistent.Match(pars2, zdo2.Persistent).GetValueOrDefault())
			{
				return false;
			}
			if (Distant != null && Distant.Match(pars2, zdo2.Distant).GetValueOrDefault())
			{
				return false;
			}
			if (Priority.HasValue && Priority.Value == zdo2.Type)
			{
				return false;
			}
			if (Items != null)
			{
				return !ItemValue.Match(pars2, Items, zdo2, ItemAmount);
			}
			if (ItemAmount != null)
			{
				return !ItemValue.Match(pars2, zdo2, ItemAmount);
			}
			if (ConnectionType.HasValue)
			{
				if ((int)ConnectionType.Value == 0)
				{
					ZDOConnection connection = zdo2.GetConnection();
					if (connection == null || connection.m_target == ZDOID.None)
					{
						return false;
					}
				}
				else
				{
					ZDOID connectionZDOID = zdo2.GetConnectionZDOID(ConnectionType.Value);
					if (TargetConnectionId == null)
					{
						if (connectionZDOID != ZDOID.None)
						{
							return false;
						}
					}
					else
					{
						ZDOID? val = TargetConnectionId.Get(pars2);
						if (val.HasValue)
						{
							ZDOID val2 = connectionZDOID;
							ZDOID? val3 = val;
							if (val3.HasValue && val2 == val3.GetValueOrDefault())
							{
								return false;
							}
						}
					}
				}
			}
			return true;
		}

		private string GetString(ZDO zdo, int key)
		{
			return ZdoHelper.TryGetString(zdo, key) ?? "";
		}

		private float GetFloat(ZDO zdo, int key)
		{
			return ZdoHelper.TryGetFloat(zdo, key).GetValueOrDefault();
		}

		private int GetInt(ZDO zdo, int key)
		{
			return ZdoHelper.TryGetInt(zdo, key).GetValueOrDefault();
		}

		private long GetLong(ZDO zdo, int key)
		{
			return ZdoHelper.TryGetLong(zdo, key).GetValueOrDefault();
		}

		private bool GetBool(ZDO zdo, int key)
		{
			return ZdoHelper.TryGetBool(zdo, key).GetValueOrDefault();
		}

		private Vector3 GetVec(ZDO zdo, int key)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return (Vector3)(((??)ZdoHelper.TryGetVec(zdo, key)) ?? Vector3.zero);
		}

		private Quaternion GetQuaternion(ZDO zdo, int key)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return (Quaternion)(((??)ZdoHelper.TryGetQuaternion(zdo, key)) ?? Quaternion.identity);
		}

		public static string PrintVectorXZY(Vector3 vector)
		{
			return vector.x.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.z.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.y.ToString("0.##", CultureInfo.InvariantCulture);
		}

		public static string PrintAngleYXZ(Quaternion quaternion)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return PrintVectorYXZ(((Quaternion)(ref quaternion)).eulerAngles);
		}

		private static string PrintVectorYXZ(Vector3 vector)
		{
			return vector.y.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.x.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.z.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static T ToByteEnum<T>(List<string> list) where T : struct, Enum
		{
			byte b = 0;
			foreach (string item in list)
			{
				string text = item.Trim();
				if (Enum.TryParse<T>(text, ignoreCase: true, out var result))
				{
					b += (byte)(object)result;
				}
				else
				{
					Log.Warning("Failed to parse value " + text + " as T.");
				}
			}
			return (T)(object)b;
		}

		public void RollItems(Parameters pars, ZDO zdo)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			List<ItemValue>? items = Items;
			if (items != null && items.Count > 0)
			{
				Vector2i size = (Vector2i)(((??)ContainerSize) ?? ZdoHelper.GetInventorySize(this, pars, zdo));
				string value = ItemValue.LoadItems(pars, Items, size, (ItemAmount?.Get(pars)).GetValueOrDefault());
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				Strings[ZDOVars.s_items] = DataValue.Simple(value);
			}
		}

		public void AddItems(Parameters parameters, ZDO zdo)
		{
			//IL_0032: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_004d: 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_0089: Expected O, but got Unknown
			if (Items == null || Items.Count == 0)
			{
				return;
			}
			Vector2i val = (Vector2i)(((??)ContainerSize) ?? ZdoHelper.GetInventorySize(this, parameters, zdo));
			Inventory val2 = ItemValue.CreateInventory(zdo, val.x, val.y);
			foreach (ItemValue item in GenerateItems(parameters, val))
			{
				item.AddTo(parameters, val2);
			}
			ZPackage val3 = new ZPackage();
			val2.Save(val3);
			zdo.Set(ZDOVars.s_items, val3.GetBase64());
		}

		public void RemoveItems(Parameters parameters, ZDO zdo)
		{
			//IL_0041: 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_0080: Expected O, but got Unknown
			if (Items == null || Items.Count == 0)
			{
				return;
			}
			Inventory val = ItemValue.CreateInventory(zdo);
			if (val.m_inventory.Count == 0)
			{
				return;
			}
			foreach (ItemValue item in GenerateItems(parameters, new Vector2i(10000, 10000)))
			{
				item.RemoveFrom(parameters, val);
			}
			ZPackage val2 = new ZPackage();
			val.Save(val2);
			zdo.Set(ZDOVars.s_items, val2.GetBase64());
		}

		public List<ItemValue> GenerateItems(Parameters pars, Vector2i size)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Items == null)
			{
				throw new ArgumentNullException("Items");
			}
			return ItemValue.Generate(pars, Items, size, (ItemAmount?.Get(pars)).GetValueOrDefault());
		}
	}
	public class DataHelper
	{
		public static DataEntry? Merge(params DataEntry?[] datas)
		{
			DataEntry[] array = datas.Where((DataEntry d) => d != null).ToArray();
			if (array.Length == 0)
			{
				return null;
			}
			if (array.Length == 1)
			{
				return array[0];
			}
			DataEntry dataEntry = new DataEntry();
			DataEntry[] array2 = array;
			foreach (DataEntry data in array2)
			{
				dataEntry.Load(data);
			}
			return dataEntry;
		}

		public static bool Exists(int hash)
		{
			return DataLoading.Data.ContainsKey(hash);
		}

		public static bool Match(int hash, ZDO zdo, Parameters pars)
		{
			if (DataLoading.Data.TryGetValue(hash, out DataEntry value))
			{
				return value.Match(pars, zdo);
			}
			return false;
		}

		public static DataEntry? Get(string name)
		{
			if (!(name == ""))
			{
				return DataLoading.Get(name);
			}
			return null;
		}

		public static DataEntry? Get(IStringValue? name, Parameters parameters)
		{
			if (name == null)
			{
				return null;
			}
			string whole = name.GetWhole(parameters);
			if (whole == null)
			{
				return null;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(whole);
			if (DataLoading.TryGet(stableHashCode, out DataEntry entry))
			{
				return entry;
			}
			if (!Enumerable.Contains(whole, ','))
			{
				return Get(whole);
			}
			string[] array = (from s in whole.Split(new char[1] { ',' }, 3)
				select s.Trim()).ToArray();
			if (array.Length > 2 && DataEntry.SupportedTypes.Contains(array[0]))
			{
				DataEntry dataEntry = new DataEntry(array);
				DataLoading.Add(stableHashCode, dataEntry);
				return dataEntry;
			}
			return Get(name.Get(parameters) ?? "");
		}

		public static int GetHash(string name)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (Enumerable.Contains(name, ','))
			{
				string[] array = (from s in name.Split(new char[1] { ',' }, 3)
					select s.Trim()).ToArray();
				if (array.Length > 2 && DataEntry.SupportedTypes.Contains(array[0]))
				{
					DataEntry entry = new DataEntry(array);
					DataLoading.Add(stableHashCode, entry);
					return stableHashCode;
				}
			}
			Get(name);
			return stableHashCode;
		}

		public static List<string>? GetValuesFromGroup(string group)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(group.ToLowerInvariant());
			if (DataLoading.ValueGroups.TryGetValue(stableHashCode, out List<string> value))
			{
				return value;
			}
			return null;
		}

		public static List<string> ResolvePrefabs(string values)
		{
			HashSet<string> hashSet = new HashSet<string>();
			ResolvePrefabsSub(hashSet, values);
			HashSet<string> hashSet2 = hashSet;
			List<string> list = new List<string>(hashSet2.Count);
			list.AddRange(hashSet2);
			return list;
		}

		private static void ResolvePrefabsSub(HashSet<string> prefabs, string value)
		{
			if (value == "all" || ZNetScene.instance.m_namedPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(value)))
			{
				prefabs.Add(value);
				return;
			}
			List<string> valuesFromGroup = GetValuesFromGroup(value);
			if (valuesFromGroup != null)
			{
				foreach (string item in valuesFromGroup)
				{
					ResolvePrefabsSub(prefabs, item);
				}
				return;
			}
			Log.Warning("Failed to resolve prefab: " + value);
		}

		public static string GetGlobalKey(string key)
		{
			string lower = key.ToLowerInvariant();
			return ZoneSystem.instance.m_globalKeysValues.FirstOrDefault((KeyValuePair<string, string> kvp) => kvp.Key.ToLowerInvariant() == lower).Value ?? "0";
		}
	}
	public class DataLoading
	{
		private static readonly string GamePath = Path.GetFullPath(Path.Combine("BepInEx", "config", "data"));

		private static readonly string ProfilePath = Path.GetFullPath(Path.Combine(Paths.ConfigPath, "data"));

		public static Dictionary<int, DataEntry> Data = new Dictionary<int, DataEntry>();

		public static readonly Dictionary<int, List<string>> ValueGroups = new Dictionary<int, List<string>>();

		private static readonly Dictionary<int, List<string>> DefaultValueGroups = new Dictionary<int, List<string>>();

		private static readonly int WearNTearHash = StringExtensionMethods.GetStableHashCode("wearntear");

		private static readonly int HumanoidHash = StringExtensionMethods.GetStableHashCode("humanoid");

		private static readonly int CreatureHash = StringExtensionMethods.GetStableHashCode("creature");

		private static readonly int StructureHash = StringExtensionMethods.GetStableHashCode("structure");

		public static string Pattern = "expand_data*.yaml";

		public static void Add(int hash, DataEntry entry)
		{
			Data[hash] = entry;
		}

		public static DataEntry? Get(string name)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			DataEntry dataEntry = Get(StringExtensionMethods.GetStableHashCode(name));
			if (dataEntry != null)
			{
				return dataEntry;
			}
			if (name.Length >= 12 && name.Length % 4 == 0)
			{
				try
				{
					DataEntry dataEntry2 = new DataEntry(new ZPackage(name));
					Data[StringExtensionMethods.GetStableHashCode(name)] = dataEntry2;
					return dataEntry2;
				}
				catch
				{
					Log.Error("Failed to decode base64 data: " + name);
				}
			}
			Log.Warning("Data entry not found: " + name);
			return null;
		}

		public static DataEntry? Get(int hash)
		{
			if (!Data.ContainsKey(hash))
			{
				return null;
			}
			return Data[hash];
		}

		public static bool TryGet(int hash, out DataEntry? entry)
		{
			entry = (Data.ContainsKey(hash) ? Data[hash] : null);
			return entry != null;
		}

		public static void LoadEntries()
		{
			Dictionary<int, DataEntry> data = Data;
			Data = new Dictionary<int, DataEntry>();
			ValueGroups.Clear();
			List<DataData> list = Yaml.Read<DataData>(Directory.GetFiles(GamePath, "*.yaml").Concat(Directory.GetFiles(ProfilePath, "*.yaml")).Concat(Directory.GetFiles(Yaml.BaseDirectory, Pattern))
				.Select(Path.GetFullPath)
				.Distinct()
				.ToList(), migrate: false);
			foreach (DataData item in list)
			{
				LoadValues(item);
			}
			if (ValueGroups.Count > 0)
			{
				Log.Info($"Loaded {ValueGroups.Count} value groups.");
			}
			LoadDefaultValueGroups();
			foreach (KeyValuePair<int, List<string>> valueGroup in ValueGroups)
			{
				ResolveValues(valueGroup.Value);
			}
			foreach (KeyValuePair<int, List<string>> defaultValueGroup in DefaultValueGroups)
			{
				if (!ValueGroups.ContainsKey(defaultValueGroup.Key))
				{
					ValueGroups[defaultValueGroup.Key] = defaultValueGroup.Value;
				}
			}
			foreach (DataData item2 in list)
			{
				LoadEntry(item2, data);
			}
			PrefabHelper.ClearCache();
			Log.Info($"Loaded {Data.Count} data entries.");
		}

		private static void LoadValues(DataData data)
		{
			if (data.value != null)
			{
				KeyValuePair<string, string> keyValuePair = Parse.Kvp(data.value);
				int stableHashCode = StringExtensionMethods.GetStableHashCode(keyValuePair.Key.ToLowerInvariant());
				if (ValueGroups.ContainsKey(stableHashCode))
				{
					Log.Warning("Duplicate value group entry: " + keyValuePair.Key);
				}
				if (!ValueGroups.ContainsKey(stableHashCode))
				{
					ValueGroups[stableHashCode] = new List<string>();
				}
				ValueGroups[stableHashCode].Add(keyValuePair.Value);
			}
			if (data.valueGroup != null && data.values != null)
			{
				int stableHashCode2 = StringExtensionMethods.GetStableHashCode(data.valueGroup.ToLowerInvariant());
				if (ValueGroups.ContainsKey(stableHashCode2))
				{
					Log.Warning("Duplicate value group entry: " + data.valueGroup);
				}
				if (!ValueGroups.ContainsKey(stableHashCode2))
				{
					ValueGroups[stableHashCode2] = new List<string>();
				}
				string[] values = data.values;
				foreach (string item in values)
				{
					ValueGroups[stableHashCode2].Add(item);
				}
			}
		}

		private static void LoadEntry(DataData data, Dictionary<int, DataEntry> oldData)
		{
			if (data.name != null)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(data.name);
				if (Data.ContainsKey(stableHashCode))
				{
					Log.Warning("Duplicate data entry: " + data.name);
				}
				Data[stableHashCode] = (oldData.TryGetValue(stableHashCode, out DataEntry value) ? value.Reset(data) : new DataEntry(data));
			}
		}

		private static void LoadDefaultValueGroups()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (DefaultValueGroups.Count == 0)
			{
				foreach (GameObject value in ZNetScene.instance.m_namedPrefabs.Values)
				{
					if (!Object.op_Implicit((Object)(object)value))
					{
						continue;
					}
					value.GetComponentsInChildren<MonoBehaviour>(ZNetView.m_tempComponents);
					foreach (MonoBehaviour tempComponent in ZNetView.m_tempComponents)
					{
						AddDefaultValue(((object)tempComponent).GetType().Name, ((Object)value).name);
						WearNTear val = (WearNTear)(object)((tempComponent is WearNTear) ? tempComponent : null);
						if (val != null)
						{
							AddDefaultValue($"material_{val.m_materialType}", ((Object)value).name);
						}
						ItemDrop val2 = (ItemDrop)(object)((tempComponent is ItemDrop) ? tempComponent : null);
						if (val2 != null)
						{
							AddDefaultValue($"itemtype_{val2.m_itemData.m_shared.m_itemType}", ((Object)value).name);
						}
					}
				}
			}
			DefaultValueGroups[CreatureHash] = DefaultValueGroups[HumanoidHash];
			DefaultValueGroups[StructureHash] = DefaultValueGroups[WearNTearHash];
		}

		private static void AddDefaultValue(string name, string prefab)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name.ToLowerInvariant().Replace(" ", "_"));
			if (!DefaultValueGroups.ContainsKey(stableHashCode))
			{
				DefaultValueGroups[stableHashCode] = new List<string>();
			}
			DefaultValueGroups[stableHashCode].Add(prefab);
		}

		private static void ResolveValues(List<string> values)
		{
			for (int i = 0; i < values.Count; i++)
			{
				string text = values[i];
				if (text.StartsWith("<", StringComparison.OrdinalIgnoreCase) && text.EndsWith(">", StringComparison.OrdinalIgnoreCase))
				{
					string text2 = text.Substring(1, text.Length - 2);
					List<string> value2;
					if (ValueGroups.TryGetValue(StringExtensionMethods.GetStableHashCode(text2.ToLowerInvariant()), out List<string> value))
					{
						values.RemoveAt(i);
						values.InsertRange(i, value);
						i--;
					}
					else if (DefaultValueGroups.TryGetValue(StringExtensionMethods.GetStableHashCode(text2.ToLowerInvariant()), out value2))
					{
						values.RemoveAt(i);
						values.InsertRange(i, value2);
						i += value2.Count - 1;
					}
				}
			}
		}

		public static void SetupWatcher()
		{
			if (!Directory.Exists(GamePath))
			{
				Directory.CreateDirectory(GamePath);
			}
			if (!Directory.Exists(ProfilePath))
			{
				Directory.CreateDirectory(ProfilePath);
			}
			if (!Directory.Exists(Yaml.BaseDirectory))
			{
				Directory.CreateDirectory(Yaml.BaseDirectory);
			}
			Yaml.SetupWatcher(GamePath, "*", LoadEntries, overwriteBackup: true);
			if (GamePath != ProfilePath)
			{
				Yaml.SetupWatcher(ProfilePath, "*", LoadEntries, overwriteBackup: true);
			}
			Yaml.SetupWatcher(Pattern, LoadEntries, overwriteBackup: true);
		}
	}
	public class DataValue
	{
		public static IZdoIdValue ZdoId(string values)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			string[] array = SplitWithValues(values);
			ZDOID val = Parse.ZdoId(array[0]);
			if (array.Length == 1 && val != ZDOID.None)
			{
				return new SimpleZdoIdValue(val);
			}
			return new ZdoIdValue(array);
		}

		public static IIntValue Simple(int value)
		{
			return new SimpleIntValue(value);
		}

		public static IStringValue Simple(string value)
		{
			return new SimpleStringValue(value);
		}

		public static IFloatValue Simple(float value)
		{
			return new SimpleFloatValue(value);
		}

		public static ILongValue Simple(long value)
		{
			return new SimpleLongValue(value);
		}

		public static IVector3Value Simple(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return new SimpleVector3Value(value);
		}

		public static IQuaternionValue Simple(Quaternion value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return new SimpleQuaternionValue(value);
		}

		public static IBytesValue Simple(byte[]? value)
		{
			return new SimpleBytesValue(value);
		}

		public static IIntValue Int(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && int.TryParse(array[0], out var result))
			{
				return new SimpleIntValue(result);
			}
			return new IntValue(array);
		}

		public static IFloatValue Float(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && Parse.TryFloat(array[0], out var result))
			{
				return new SimpleFloatValue(result);
			}
			return new FloatValue(array);
		}

		public static ILongValue Long(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && long.TryParse(array[0], out var result))
			{
				return new SimpleLongValue(result);
			}
			return new LongValue(array);
		}

		public static IStringValue String(string values)
		{
			if (values.Length > 2 && values[0] == '"' && values[values.Length - 1] == '"')
			{
				return new SimpleStringValue(values.Substring(1, values.Length - 2));
			}
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && !HasParameters(array[0]))
			{
				return new SimpleStringValue(array[0]);
			}
			return new StringValue(array);
		}

		public static IBoolValue Bool(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && bool.TryParse(array[0], out var result))
			{
				return new SimpleBoolValue(result);
			}
			return new BoolValue(array);
		}

		public static IBytesValue Bytes(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && !HasParameters(array[0]))
			{
				if (string.IsNullOrEmpty(array[0]))
				{
					return new SimpleBytesValue(null);
				}
				try
				{
					return new SimpleBytesValue(Convert.FromBase64String(array[0]));
				}
				catch (FormatException)
				{
				}
			}
			return new BytesValue(array);
		}

		public static IHashValue Hash(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && !HasParameters(array[0]))
			{
				return new SimpleHashValue(array[0]);
			}
			return new HashValue(array);
		}

		public static IPrefabValue Prefab(string values)
		{
			if (HasParameters(values))
			{
				return new PrefabValue(SplitWithValues(values));
			}
			List<int> prefabs = PrefabHelper.GetPrefabs(values, "");
			if (prefabs.Count == 0)
			{
				return new SimplePrefabValue(null);
			}
			if (prefabs.Count == 1)
			{
				return new SimplePrefabValue(prefabs[0]);
			}
			return new SimplePrefabsValue(prefabs);
		}

		public static IVector3Value Vector3(string values)
		{
			//IL_0095: 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)
			string[] array = SplitWithValues(values);
			if (HasParameters(values) || array.Length > 3)
			{
				List<string> list = new List<string>();
				for (int i = 0; i < array.Length; i += 3)
				{
					string[] array2;
					if (i + 3 >= array.Length)
					{
						List<string> list2 = new List<string>();
						list2.AddRange(array.Skip(i));
						array2 = list2.ToArray();
					}
					else
					{
						array2 = array.Skip(i).Take(3).ToArray();
					}
					string[] value = array2;
					list.Add(string.Join(",", value));
				}
				return new Vector3Value(list.ToArray());
			}
			Vector3? val = Parse.VectorXZYNull(array);
			return new SimpleVector3Value(val.HasValue ? val.Value : Vector3.zero);
		}

		public static IQuaternionValue Quaternion(string values)
		{
			//IL_0095: 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)
			string[] array = SplitWithValues(values);
			if (HasParameters(values) || array.Length > 3)
			{
				List<string> list = new List<string>();
				for (int i = 0; i < array.Length; i += 3)
				{
					string[] array2;
					if (i + 3 >= array.Length)
					{
						List<string> list2 = new List<string>();
						list2.AddRange(array.Skip(i));
						array2 = list2.ToArray();
					}
					else
					{
						array2 = array.Skip(i).Take(3).ToArray();
					}
					string[] value = array2;
					list.Add(string.Join(",", value));
				}
				return new QuaternionValue(list.ToArray());
			}
			Quaternion? val = Parse.AngleYXZNull(array);
			return new SimpleQuaternionValue(val.HasValue ? val.Value : Quaternion.identity);
		}

		private static bool HasParameters(string value)
		{
			if (value.Contains("<"))
			{
				return value.Contains(">");
			}
			return false;
		}

		private static string[] SplitWithValues(string str)
		{
			List<string> list = new List<string>();
			string[] array = Parse.SplitWithEmpty(str);
			foreach (string text in array)
			{
				if (!text.Contains("<") || !text.Contains(">"))
				{
					list.Add(text);
					continue;
				}
				string[] array2 = text.Split('<', '>');
				List<string> list2 = new List<string>();
				List<int> list3 = new List<int>();
				for (int j = 1; j < array2.Length; j += 2)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(array2[j].ToLowerInvariant());
					if (DataLoading.ValueGroups.ContainsKey(stableHashCode))
					{
						list2.Add("<" + array2[j] + ">");
						list3.Add(stableHashCode);
					}
				}
				if (list2.Count == 0)
				{
					list.Add(text);
					if (list.Count > 1000)
					{
						break;
					}
				}
				else
				{
					SubstitueValues(list, text, list2, list3, 0);
				}
			}
			if (list.Count > 1000)
			{
				Log.Warning("Too many values loaded for " + str);
			}
			if (list.Count <= 1000)
			{
				return list.ToArray();
			}
			return new string[1] { str };
		}

		private static void SubstitueValues(List<string> result, string format, List<string> parameters, List<int> hashes, int index)
		{
			foreach (string item in DataLoading.ValueGroups[hashes[index]])
			{
				string text = format.Replace(parameters[index], item);
				if (index == parameters.Count - 1)
				{
					result.Add(text);
					if (result.Count > 1000)
					{
						break;
					}
				}
				else
				{
					SubstitueValues(result, text, parameters, hashes, index + 1);
				}
			}
		}
	}
	public class AnyValue
	{
		protected readonly string[] Values;

		public AnyValue(string[] values)
		{
			Values = values;
			base..ctor();
		}

		private string? RollValue()
		{
			if (Values.Length == 1)
			{
				return Values[0];
			}
			return Values[Random.Range(0, Values.Length)];
		}

		protected string? GetValue(Parameters pars)
		{
			string text = RollValue();
			if (text == null || text == "<none>")
			{
				return null;
			}
			return pars.Replace(text);
		}

		protected string? GetValue()
		{
			string text = RollValue();
			if (text != null && !(text == "<none>"))
			{
				return text;
			}
			return null;
		}

		protected List<string> GetAllValues(Parameters pars)
		{
			List<string> list = new List<string>();
			list.AddRange(from v in Values.Select(pars.Replace)
				where v != null && v != "" && v != "<none>"
				select v);
			return list;
		}

		protected string GetWholeValue(Parameters pars)
		{
			return string.Join(",", Values.Select(pars.Replace));
		}
	}
	public class ItemValue
	{
		public IPrefabValue Prefab = DataValue.Prefab(data.prefab);

		public float Chance = data.chance;

		public IIntValue? Stack = ((data.stack == null) ? null : DataValue.Int(data.stack));

		public IFloatValue? Durability = ((data.durability == null) ? null : DataValue.Float(data.durability));

		public string Position = data.pos;

		private Vector2i RolledPosition = Parse.Vector2Int(data.pos);

		public IBoolValue? Equipped = ((data.equipped == null) ? null : DataValue.Bool(data.equipped));

		public IIntValue? Quality = ((data.quality == null) ? null : DataValue.Int(data.quality));

		public IIntValue? Variant = ((data.variant == null) ? null : DataValue.Int(data.variant));

		public ILongValue? CrafterID = ((data.crafterID == null) ? null : DataValue.Long(data.crafterID));

		public IStringValue? CrafterName = ((data.crafterName == null) ? null : DataValue.String(data.crafterName));

		public Dictionary<string, IStringValue>? CustomData = data.customData?.ToDictionary((KeyValuePair<string, string> kvp) => kvp.Key, (KeyValuePair<string, string> kvp) => DataValue.String(kvp.Value));

		public IIntValue? WorldLevel = ((data.worldLevel == null) ? null : DataValue.Int(data.worldLevel));

		public IBoolValue? PickedUp = ((data.pickedUp == null) ? null : DataValue.Bool(data.pickedUp));

		private int RolledPrefab;

		private int RolledStack;

		public ItemValue(ItemData data)
		{
		}//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)


		public static bool Match(Parameters pars, List<ItemValue> data, ZDO zdo, IIntValue? amount)
		{
			Parameters pars2 = pars;
			Inventory inv = CreateInventory(zdo);
			int num = data.Where((ItemValue item) => item.Match(pars2, inv)).Count();
			if (amount == null)
			{
				if (num == data.Count)
				{
					return inv.m_inventory.Count == 0;
				}
				return false;
			}
			return amount.Match(pars2, num).GetValueOrDefault();
		}

		public static bool Match(Parameters pars, ZDO zdo, IIntValue amount)
		{
			Inventory val = CreateInventory(zdo);
			return amount.Match(pars, val.m_inventory.Count).GetValueOrDefault();
		}

		public static Inventory CreateInventory(ZDO zdo, int width = 100000, int height = 10000)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			Inventory val = new Inventory("", (Sprite)null, width, height);
			string @string = zdo.GetString(ZDOVars.s_items, "");
			if (@string != "")
			{
				ZPackage val2 = new ZPackage(@string);
				val.Load(val2);
			}
			return val;
		}

		public static string LoadItems(Parameters pars, List<ItemValue> items, Vector2i size, int amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(106);
			items = Generate(pars, items, size, amount);
			val.Write(items.Count);
			foreach (ItemValue item in items)
			{
				item.Write(pars, val);
			}
			return val.GetBase64();
		}

		public static List<ItemValue> Generate(Parameters pars, List<ItemValue> data, Vector2i size, int amount)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			List<ItemValue> list = data.Where((ItemValue item) => item.Position != "").ToList();
			List<ItemValue> items = data.Where((ItemValue item) => item.Position == "").ToList();
			Dictionary<Vector2i, ItemValue> dictionary = new Dictionary<Vector2i, ItemValue>();
			foreach (ItemValue item in list)
			{
				if (item.Roll(pars))
				{
					dictionary[item.RolledPosition] = item;
				}
			}
			if (amount == 0)
			{
				GenerateEach(pars, dictionary, size, items);
			}
			else
			{
				GenerateAmount(pars, dictionary, size, items, amount);
			}
			Dictionary<Vector2i, ItemValue>.ValueCollection values = dictionary.Values;
			List<ItemValue> list2 = new List<ItemValue>(values.Count);
			list2.AddRange(values);
			return list2;
		}

		private static void GenerateEach(Parameters pars, Dictionary<Vector2i, ItemValue> inventory, Vector2i size, List<ItemValue> items)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemValue item in items)
			{
				if (item.Roll(pars))
				{
					Vector2i? val = FindNextFreeSlot(inventory, size);
					if (!val.HasValue)
					{
						break;
					}
					item.RolledPosition = val.Value;
					inventory[val.Value] = item;
				}
			}
		}

		private static void GenerateAmount(Parameters pars, Dictionary<Vector2i, ItemValue> inventory, Vector2i size, List<ItemValue> items, int amount)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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)
			float num = items.Sum((ItemValue item) => item.Chance);
			for (int i = 0; i < amount; i++)
			{
				if (items.Count <= 0)
				{
					break;
				}
				Vector2i? val = FindNextFreeSlot(inventory, size);
				if (val.HasValue)
				{
					ItemValue itemValue = RollItem(items, num);
					itemValue.RolledPosition = val.Value;
					if (itemValue.RollPrefab(pars))
					{
						inventory[val.Value] = itemValue;
					}
					num -= itemValue.Chance;
					items.Remove(itemValue);
					continue;
				}
				break;
			}
		}

		private static ItemValue RollItem(List<ItemValue> items, float maxWeight)
		{
			float num = Random.Range(0f, maxWeight);
			foreach (ItemValue item in items)
			{
				if (num < item.Chance)
				{
					return item;
				}
				num -= item.Chance;
			}
			return items.Last();
		}

		private static Vector2i? FindNextFreeSlot(Dictionary<Vector2i, ItemValue> inventory, Vector2i size)
		{
			//IL_0000: 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)
			//IL_0020: 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)
			int x = size.x;
			int y = size.y;
			Vector2i val = default(Vector2i);
			for (int i = 0; i < y; i++)
			{
				for (int j = 0; j < x; j++)
				{
					((Vector2i)(ref val))..ctor(j, i);
					if (!inventory.ContainsKey(val))
					{
						return val;
					}
				}
			}
			return null;
		}

		public bool RollPrefab(Parameters pars)
		{
			RolledPrefab = Prefab.Get(pars).GetValueOrDefault();
			RolledStack = (Stack?.Get(pars)).GetValueOrDefault(1);
			if (RolledPrefab != 0)
			{
				return RolledStack != 0;
			}
			return false;
		}

		public bool RollChance()
		{
			if (!(Chance >= 1f))
			{
				return Random.value <= Chance;
			}
			return true;
		}

		public bool Roll(Parameters pars)
		{
			if (RollChance())
			{
				return RollPrefab(pars);
			}
			return false;
		}

		public void Write(Parameters pars, ZPackage pkg)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(RolledPrefab);
			pkg.Write(((itemPrefab != null) ? ((Object)itemPrefab).name : null) ?? "");
			int valueOrDefault = (Quality?.Get(pars)).GetValueOrDefault(1);
			float? num = Durability?.Get(pars);
			if (!num.HasValue)
			{
				ItemDrop val = default(ItemDrop);
				num = ((!((Object)(object)itemPrefab != (Object)null) || !itemPrefab.TryGetComponent<ItemDrop>(ref val)) ? new float?(100f) : new float?(val.m_itemData.GetMaxDurability(valueOrDefault)));
			}
			pkg.Write(RolledStack);
			pkg.Write(num.Value);
			pkg.Write(RolledPosition);
			pkg.Write((Equipped?.GetBool(pars)).GetValueOrDefault());
			pkg.Write(valueOrDefault);
			pkg.Write((Variant?.Get(pars)).GetValueOrDefault());
			pkg.Write((CrafterID?.Get(pars)).GetValueOrDefault());
			pkg.Write(CrafterName?.Get(pars) ?? "");
			pkg.Write(CustomData?.Count ?? 0);
			if (CustomData != null)
			{
				foreach (KeyValuePair<string, IStringValue> customDatum in CustomData)
				{
					pkg.Write(customDatum.Key);
					pkg.Write(customDatum.Value.Get(pars));
				}
			}
			pkg.Write((WorldLevel?.Get(pars)).GetValueOrDefault());
			pkg.Write((PickedUp?.GetBool(pars)).GetValueOrDefault());
		}

		public void Spawn(ZDO source, Parameters pars)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = ZNetScene.instance.GetPrefab(RolledPrefab);
			if ((Object)(object)prefab == (Object)null)
			{
				Log.Error($"Can't spawn missing drop: {RolledPrefab}");
				return;
			}
			Vector3 position = source.m_position;
			if (Object.op_Implicit((Object)(object)prefab.GetComponent<ItemDrop>()))
			{
				ZDO val = ZdoEntry.Spawn(RolledPrefab, position, Vector3.zero, source.GetOwner());
				if (val == null)
				{
					return;
				}
				val.Set(ZDOVars.s_durability, (Durability?.Get(pars)).GetValueOrDefault(100f));
				val.Set(ZDOVars.s_stack, RolledStack, false);
				val.Set(ZDOVars.s_quality, (Quality?.Get(pars)).GetValueOrDefault(1), false);
				val.Set(ZDOVars.s_variant, (Variant?.Get(pars)).GetValueOrDefault(), false);
				val.Set(ZDOVars.s_crafterID, (CrafterID?.Get(pars)).GetValueOrDefault());
				val.Set(ZDOVars.s_crafterName, CrafterName?.Get(pars) ?? "");
				val.Set(ZDOVars.s_dataCount, CustomData?.Count ?? 0, false);
				int num = 0;
				if (CustomData != null)
				{
					foreach (KeyValuePair<string, IStringValue> customDatum in CustomData)
					{
						val.Set($"data_{num}", customDatum.Key);
						val.Set($"data__{num}", customDatum.Value.Get(pars) ?? "");
						num++;
					}
				}
				val.Set(ZDOVars.s_worldLevel, (WorldLevel?.Get(pars)).GetValueOrDefault(), false);
				val.Set(ZDOVars.s_pickedUp, (PickedUp?.GetBool(pars)).GetValueOrDefault());
				return;
			}
			for (int i = 0; i < RolledStack; i++)
			{
				ZDO val2 = ZdoEntry.Spawn(RolledPrefab, position, Vector3.zero, source.GetOwner());
				if (val2 == null)
				{
					break;
				}
				if (Object.op_Implicit((Object)(object)prefab.GetComponent<Character>()))
				{
					val2.Set(ZDOVars.s_level, (Quality?.Get(pars)).GetValueOrDefault(1), false);
				}
				if (CustomData == null)
				{
					continue;
				}
				foreach (KeyValuePair<string, IStringValue> customDatum2 in CustomData)
				{
					LoadCustomData(val2, pars, customDatum2);
				}
			}
		}

		private void LoadCustomData(ZDO zdo, Parameters pars, KeyValuePair<string, IStringValue> kvp)
		{
			if (kvp.Key == "data")
			{
				DataEntry dataEntry = DataHelper.Get(kvp.Value.Get(pars) ?? "");
				if (dataEntry != null)
				{
					ZdoEntry zdoEntry = new ZdoEntry(zdo);
					zdoEntry.Load(dataEntry, pars);
					zdoEntry.Write(zdo);
				}
			}
		}

		public void AddTo(Parameters pars, Inventory inv)
		{
			int valueOrDefault = (Stack?.Get(pars)).GetValueOrDefault(1);
			valueOrDefault = StackTo(pars, valueOrDefault, inv);
			InsertTo(pars, valueOrDefault, inv);
		}

		private int StackTo(Parameters pars, int stack, Inventory inv)
		{
			foreach (ItemData item in inv.m_inventory)
			{
				if (MatchItem(pars, item))
				{
					int num = Mathf.Min(item.m_shared.m_maxStackSize - item.m_stack, stack);
					item.m_stack += num;
					stack -= num;
					if (stack <= 0)
					{
						break;
					}
				}
			}
			return stack;
		}

		private int InsertTo(Parameters pars, int stack, Inventory inv)
		{
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			Parameters pars2 = pars;
			ItemDrop val = default(ItemDrop);
			while (stack > 0)
			{
				int valueOrDefault = Prefab.Get(pars2).GetValueOrDefault();
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(valueOrDefault);
				if ((Object)(object)itemPrefab == (Object)null || !itemPrefab.TryGetComponent<ItemDrop>(ref val))
				{
					return stack;
				}
				ItemData val2 = val.m_itemData.Clone();
				val2.m_dropPrefab = itemPrefab;
				val2.m_quality = (Quality?.Get(pars2)).GetValueOrDefault(1);
				val2.m_variant = (Variant?.Get(pars2)).GetValueOrDefault();
				val2.m_crafterID = (CrafterID?.Get(pars2)).GetValueOrDefault();
				val2.m_crafterName = CrafterName?.Get(pars2) ?? "";
				val2.m_worldLevel = (WorldLevel?.Get(pars2)).GetValueOrDefault();
				val2.m_durability = Durability?.Get(pars2) ?? val2.GetMaxDurability(val2.m_quality);
				val2.m_equipped = (Equipped?.GetBool(pars2)).GetValueOrDefault();
				val2.m_pickedUp = (PickedUp?.GetBool(pars2)).GetValueOrDefault();
				if (CustomData != null)
				{
					val2.m_customData = CustomData.ToDictionary<KeyValuePair<string, IStringValue>, string, string>((KeyValuePair<string, IStringValue> x) => x.Key, (KeyValuePair<string, IStringValue> x) => x.Value.Get(pars2) ?? "");
				}
				int num = Mathf.Min(val2.m_shared.m_maxStackSize, stack);
				stack -= num;
				val2.m_stack = num;
				if (Position == "")
				{
					Vector2i val3 = inv.FindEmptySlot(true);
					if (val3.x < 0)
					{
						return stack;
					}
					val2.m_gridPos = val3;
					inv.m_inventory.Add(val2);
				}
				else
				{
					val2.m_gridPos = RolledPosition;
					inv.m_inventory.RemoveAll((ItemData x) => x.m_gridPos == RolledPosition);
					inv.m_inventory.Add(val2);
				}
			}
			return stack;
		}

		public void RemoveFrom(Parameters pars, Inventory inv)
		{
			int num = (Stack?.Get(pars)).GetValueOrDefault(1);
			for (int num2 = inv.m_inventory.Count - 1; num2 >= 0; num2--)
			{
				ItemData val = inv.m_inventory[num2];
				if (MatchItem(pars, val))
				{
					int num3 = Mathf.Min(val.m_stack, num);
					val.m_stack -= num3;
					num -= num3;
					if (num <= 0)
					{
						break;
					}
				}
			}
			inv.m_inventory.RemoveAll((ItemData x) => x.m_stack <= 0);
		}

		public bool Match(Parameters pars, Inventory inv)
		{
			ItemData val = FindMatch(pars, inv);
			if (val == null)
			{
				return false;
			}
			inv.RemoveItem(val);
			return true;
		}

		private ItemData? FindMatch(Parameters pars, Inventory inv)
		{
			if (Position != "")
			{
				ItemData itemAt = inv.GetItemAt(RolledPosition.x, RolledPosition.y);
				if (itemAt == null)
				{
					return null;
				}
				IIntValue? stack = Stack;
				if (stack != null && stack.Match(pars, itemAt.m_stack) == false)
				{
					return null;
				}
				if (MatchItem(pars, itemAt))
				{
					return itemAt;
				}
			}
			foreach (ItemData item in inv.m_inventory)
			{
				IIntValue? stack2 = Stack;
				if ((stack2 == null || stack2.Match(pars, item.m_stack) != false) && MatchItem(pars, item))
				{
					return item;
				}
			}
			return null;
		}

		private bool MatchItem(Parameters pars, ItemData item)
		{
			GameObject dropPrefab = item.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? item.m_shared.m_name;
			bool? flag = Prefab.Match(pars, StringExtensionMethods.GetStableHashCode(text));
			bool flag2 = false;
			if (flag == flag2)
			{
				return false;
			}
			IFloatValue? durability = Durability;
			if (durability != null)
			{
				flag = durability.Match(pars, item.m_durability);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IBoolValue? equipped = Equipped;
			if (equipped != null)
			{
				flag = equipped.Match(pars, item.m_equipped);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IIntValue? quality = Quality;
			if (quality != null)
			{
				flag = quality.Match(pars, item.m_quality);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IIntValue? variant = Variant;
			if (variant != null)
			{
				flag = variant.Match(pars, item.m_variant);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			ILongValue? crafterID = CrafterID;
			if (crafterID != null)
			{
				flag = crafterID.Match(pars, item.m_crafterID);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IStringValue? crafterName = CrafterName;
			if (crafterName != null)
			{
				flag = crafterName.Match(pars, item.m_crafterName);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IIntValue? worldLevel = WorldLevel;
			if (worldLevel != null)
			{
				flag = worldLevel.Match(pars, item.m_worldLevel);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IBoolValue? pickedUp = PickedUp;
			if (pickedUp != null)
			{
				flag = pickedUp.Match(pars, item.m_pickedUp);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			if (CustomData == null)
			{
				return true;
			}
			foreach (KeyValuePair<string, IStringValue> customDatum in CustomData)
			{
				if (!item.m_customData.TryGetValue(customDatum.Key, out var value))
				{
					flag2 = false;
				}
				else
				{
					if (customDatum.Value.Match(pars, value) != false)
					{
						continue;
					}
					flag2 = false;
				}
				goto IL_025f;
			}
			return true;
			IL_025f:
			return flag2;
		}
	}
	public class Parameters
	{
		[CompilerGenerated]
		private string <prefab>P;

		[CompilerGenerated]
		private string[] <args>P;

		[CompilerGenerated]
		private Vector3 <pos>P;

		protected const char Separator = '_';

		public static Func<string, string?> ExecuteCode = (string key) => null;

		public static Func<string, string, string?> ExecuteCodeWithValue = (string key, string value) => null;

		private readonly double time;

		public int Amount;

		public Parameters(string prefab, string[] args, Vector3 pos)
		{
			//IL_000f: 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)
			<prefab>P = prefab;
			<args>P = args;
			<pos>P = pos;
			time = ZNet.instance.GetTimeSeconds();
			base..ctor();
		}

		public string Replace(string str)
		{
			return Replace(str, preventInjections: false);
		}

		public string Replace(string str, bool preventInjections)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < str.Length; i++)
			{
				if (str[i] == '<')
				{
					if (num == 0)
					{
						stringBuilder.Append(str.Substring(num2, i - num2));
						num2 = i;
					}
					num++;
				}
				if (str[i] != '>')
				{
					continue;
				}
				if (num == 1)
				{
					string str2 = str.Substring(num2, i - num2 + 1);
					string text = ResolveParameters(str2);
					if (preventInjections && text.Contains(";"))
					{
						text = text.Replace(";", ",");
					}
					stringBuilder.Append(text);
					num2 = i + 1;
				}
				if (num > 0)
				{
					num--;
				}
			}
			if (num2 < str.Length)
			{
				stringBuilder.Append(str.Substring(num2));
			}
			return stringBuilder.ToString();
		}

		private string ResolveParameters(string str)
		{
			int num;
			for (num = 0; num < str.Length; num++)
			{
				int num2 = str.IndexOf(">", num);
				if (num2 == -1)
				{
					break;
				}
				num = num2;
				int num3 = str.LastIndexOf("<", num2);
				if (num3 != -1)
				{
					int num4 = num2 - num3 + 1;
					if (TryReplaceParameter(str.Substring(num3, num4), out string resolved))
					{
						str = str.Remove(num3, num4);
						str = str.Insert(num3, resolved);
						num = num3 - 1;
					}
					else
					{
						num = num2;
					}
				}
			}
			return str;
		}

		private bool TryReplaceParameter(string rawKey, out string? resolved)
		{
			string text = rawKey.Substring(1, rawKey.Length - 2);
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(text, '=');
			string text2 = keyValuePair.Value;
			if (text2.All((char c) => c == '='))
			{
				text2 = "";
			}
			else
			{
				text = keyValuePair.Key;
			}
			resolved = GetParameter(text, text2);
			if (resolved == null)
			{
				resolved = ResolveValue(rawKey);
			}
			return resolved != rawKey;
		}

		protected virtual string? GetParameter(string key, string defaultValue)
		{
			string text = ExecuteCode(key);
			if (text != null)
			{
				return text;
			}
			text = GetGeneralParameter(key, defaultValue);
			if (text != null)
			{
				return text;
			}
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(key, '_');
			if (keyValuePair.Value == "")
			{
				return null;
			}
			key = keyValuePair.Key;
			string value = keyValuePair.Value;
			text = ExecuteCodeWithValue(key, value);
			if (text != null)
			{
				return text;
			}
			return GetValueParameter(key, value, defaultValue);
		}

		private string? GetGeneralParameter(string key, string defaultValue)
		{
			return key switch
			{
				"prefab" => <prefab>P, 
				"safeprefab" => <prefab>P.Replace('_', '-'), 
				"par" => string.Join(" ", <args>P), 
				"par0" => GetArg(0, defaultValue), 
				"par1" => GetArg(1, defaultValue), 
				"par2" => GetArg(2, defaultValue), 
				"par3" => GetArg(3, defaultValue), 
				"par4" => GetArg(4, defaultValue), 
				"par5" => GetArg(5, defaultValue), 
				"par6" => GetArg(6, defaultValue), 
				"par7" => GetArg(7, defaultValue), 
				"par8" => GetArg(8, defaultValue), 
				"par9" => GetArg(9, defaultValue), 
				"time" => Helper.Format(time), 
				"day" => EnvMan.instance.GetDay(time).ToString(), 
				"ticks" => ((long)(time * 10000000.0)).ToString(), 
				"x" => Helper.Format(<pos>P.x), 
				"y" => Helper.Format(<pos>P.y), 
				"z" => Helper.Format(<pos>P.z), 
				"snap" => Helper.Format(WorldGenerator.instance.GetHeight(<pos>P.x, <pos>P.z)), 
				"amount" => (<args>P.Length < 2) ? Amount.ToString() : null, 
				_ => null, 
			};
		}

		protected virtual string? GetValueParameter(string key, string value, string defaultValue)
		{
			float result;
			float result2;
			float result3;
			float result4;
			float result5;
			float result6;
			float result7;
			float result8;
			float result9;
			float result10;
			KeyValuePair<string, string> kvp;
			float result11;
			float result12;
			float result13;
			KeyValuePair<string, string> kvp2;
			float result14;
			float result15;
			KeyValuePair<string, string> kvp3;
			int result16;
			int result17;
			KeyValuePair<string, string> kvp4;
			float result18;
			float result19;
			KeyValuePair<string, string> kvp5;
			int result20;
			int result21;
			int result22;
			int result23;
			int result24;
			return key switch
			{
				"sqrt" => Parse.TryFloat(value, out result) ? Mathf.Sqrt(result).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"round" => Parse.TryFloat(value, out result2) ? Mathf.Round(result2).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"ceil" => Parse.TryFloat(value, out result3) ? Mathf.Ceil(result3).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"floor" => Parse.TryFloat(value, out result4) ? Mathf.Floor(result4).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"abs" => Parse.TryFloat(value, out result5) ? Mathf.Abs(result5).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"sin" => Parse.TryFloat(value, out result6) ? Mathf.Sin(result6).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"cos" => Parse.TryFloat(value, out result7) ? Mathf.Cos(result7).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"tan" => Parse.TryFloat(value, out result8) ? Mathf.Tan(result8).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"asin" => Parse.TryFloat(value, out result9) ? Mathf.Asin(result9).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"acos" => Parse.TryFloat(value, out result10) ? Mathf.Acos(result10).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"atan" => Atan(value, defaultValue), 
				"pow" => (Parse.TryKvp(value, out kvp, '_') && Parse.TryFloat(kvp.Key, out result11) && Parse.TryFloat(kvp.Value, out result12)) ? Mathf.Pow(result11, result12).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"log" => Loga(value, defaultValue), 
				"exp" => Parse.TryFloat(value, out result13) ? Mathf.Exp(result13).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"min" => HandleMin(value, defaultValue), 
				"max" => HandleMax(value, defaultValue), 
				"add" => HandleAdd(value, defaultValue), 
				"sub" => HandleSub(value, defaultValue), 
				"mul" => HandleMul(value, defaultValue), 
				"div" => HandleDiv(value, defaultValue), 
				"mod" => HandleMod(value, defaultValue), 
				"addlong" => HandleAddLong(value, defaultValue), 
				"sublong" => HandleSubLong(value, defaultValue), 
				"mullong" => HandleMulLong(value, defaultValue), 
				"divlong" => HandleDivLong(value, defaultValue), 
				"modlong" => HandleModLong(value, defaultValue), 
				"randf" => (Parse.TryKvp(value, out kvp2, '_') && Parse.TryFloat(kvp2.Key, out result14) && Parse.TryFloat(kvp2.Value, out result15)) ? Random.Range(result14, result15).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"randi" => (Parse.TryKvp(value, out kvp3, '_') && Parse.TryInt(kvp3.Key, out result16) && Parse.TryInt(kvp3.Value, out result17)) ? Random.Range(result16, result17).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"randomfloat" => (Parse.TryKvp(value, out kvp4, '_') && Parse.TryFloat(kvp4.Key, out result18) && Parse.TryFloat(kvp4.Value, out result19)) ? Random.Range(result18, result19).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"randomint" => (Parse.TryKvp(value, out kvp5, '_') && Parse.TryInt(kvp5.Key, out result20) && Parse.TryInt(kvp5.Value, out result21)) ? Random.Range(result20, result21).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"hashof" => ZdoHelper.Hash(value).ToString(), 
				"textof" => Parse.TryInt(value, out result22) ? ZdoHelper.ReverseHash(result22) : defaultValue, 
				"len" => value.Length.ToString(CultureInfo.InvariantCulture), 
				"lower" => value.ToLowerInvariant(), 
				"upper" => value.ToUpperInvariant(), 
				"trim" => value.Trim(), 
				"left" => HandleLeft(value, defaultValue), 
				"right" => HandleRight(value, defaultValue), 
				"mid" => HandleMid(value, defaultValue), 
				"proper" => HandleProper(value, defaultValue), 
				"search" => HandleSearch(value, defaultValue), 
				"calcf" => Calculator.EvaluateFloat(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"calci" => Calculator.EvaluateInt(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"calcfloat" => Calculator.EvaluateFloat(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"calcint" => Calculator.EvaluateInt(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"calclong" => Calculator.EvaluateLong(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"par" => Parse.TryInt(value, out result23) ? GetArg(result23, defaultValue) : defaultValue, 
				"rest" => Parse.TryInt(value, out result24) ? GetRest(result24, defaultValue) : defaultValue, 
				"load" => DataStorage.GetValue(value, defaultValue), 
				"save" => SetValue(value), 
				"save++" => DataStorage.IncrementValue(value, 1L), 
				"save--" => DataStorage.IncrementValue(value, -1L), 
				"clear" => RemoveValue(value), 
				"rank" => HandleRank(value, defaultValue), 
				"small" => HandleSmall(value, defaultValue), 
				"large" => HandleLarge(value, defaultValue), 
				"eq" => HandleEqual(value, defaultValue), 
				"ne" => HandleNotEqual(value, defaultValue), 
				"gt" => HandleGreater(value, defaultValue), 
				"ge" => HandleGreaterOrEqual(value, defaultValue), 
				"lt" => HandleLess(value, defaultValue), 
				"le" => HandleLessOrEqual(value, defaultValue), 
				"even" => HandleEven(value, defaultValue), 
				"odd" => HandleOdd(value, defaultValue), 
				"findupper" => HandleFindUpper(value, defaultValue), 
				"findlower" => HandleFindLower(value, defaultValue), 
				_ => null, 
			};
		}

		private string HandleMin(string value, string defaultValue)
		{
			string[] array = value.Split(new char[1] { '_' });
			if (array.Length == 0)
			{
				return defaultValue;
			}
			return array.Select((string v) => Parse.Float(v, float.MaxValue)).Min().ToString(CultureInfo.InvariantCulture);
		}

		private string HandleMax(string value, string defaultValue)
		{
			string[] array = value.Split(new char[1] { '_' });
			if (array.Length == 0)
			{
				return defaultValue;
			}
			return array.Select((string v) => Parse.Float(v, float.MinValue)).Max().ToString(CultureInfo.InvariantCulture);
		}

		private string SetValue(string value)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '_');
			if (keyValuePair.Value == "")
			{
				return "";
			}
			DataStorage.SetValue(keyValuePair.Key, keyValuePair.Value);
			return keyValuePair.Value;
		}

		private string RemoveValue(string value)
		{
			DataStorage.SetValue(value, "");
			return "";
		}

		private string GetRest(int index, string defaultValue = "")
		{
			if (index < 0 || index >= <args>P.Length)
			{
				return defaultValue;
			}
			return string.Join(" ", <args>P, index, <args>P.Length - index);
		}

		private string Atan(string value, string defaultValue)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '_');
			if (!Parse.TryFloat(keyValuePair.Key, out var result))
			{
				return defaultValue;
			}
			if (keyValuePair.Value == "")
			{
				return Mathf.Atan(result).ToString(CultureInfo.InvariantCulture);
			}
			if (!Parse.TryFloat(keyValuePair.Value, out var result2))
			{
				return defaultValue;
			}
			return Mathf.Atan2(result, result2).ToString(CultureInfo.InvariantCulture);
		}

		private string Loga(string value, string defaultValue)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '_');
			if (!Parse.TryFloat(keyValuePair.Key, out var result))
			{
				return defaultValue;
			}
			if (keyValuePair.Value == "")
			{
				return Mathf.Log(result).ToString(CultureInfo.InvariantCulture);
			}
			if (!Parse.TryFloat(keyValuePair.Value, out var result2))
			{
				return defaultValue;
			}
			return Mathf.Log(result, result2).ToString(CultureInfo.InvariantCulture);
		}

		private string HandleAdd(string value, string defaultValue)
		{
			string[] array = value.Split(new char[1] { '_' });
			if (array.Length == 0)
			{
				return defaultValue;
			}
			float num = 0f;
			string[] array2 = array;
			foreach (string arg in array2)
			{
				num += Parse.Float(arg);
			}
			return num.ToString(CultureInfo.InvariantCulture);
		}

		private string HandleSub(string value, string defaultValue)
		{
			string[] array = value.Split(new char[1] { '_' });
			if (array.Length == 0)
			{
				return defaultValue;
			}
			float num = Parse.Float(array[0]);
			for (int i = 1; i < array.Length; i++)
			{
				num -= Parse.Float(array[i]);
			}
			return num.ToString(CultureInfo.InvariantCulture);
		}

		private string HandleMul(string value, string defaultValue)
		{
			string[] array = value.Split(new char[1] { '_' });
			if (array.Length == 0)
			{
				return defaultValue;
			}
			float num = 1f;
			string[] array2 = array;
			foreach (string arg in array2)
			{
				num *= Parse.Float(arg, 1f);
			}
			return num.ToString(CultureInfo.InvariantCulture);
		}

		private string HandleDiv(string value, string defaultValue)
		{
			string[] array = value.Split(new char[1] { '_' });
			if (array.Length == 0)
			{
				return defaultValue;
			}
			float num = Parse.Float(array[0]);
			for (int i = 1; i < array.Length; i++)
			{
				float num2 = Parse.Float(array[i], 1f);
				if (num2 == 0f)
				{
					return defaultValue;
				}
				num /= num2;
			}
			return num.ToString(CultureInfo.InvariantCulture);
		}

		private string HandleMod(string value, string defaultValue)
		{
			string[] array = value.Split(