using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("RlValheimLink.Contract")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("RL Valheim Link: message model, JSON writer, pre-send validator and encoders for the pinned Raid Ledger valheim-link v1 contract. No Unity or game references.")]
[assembly: AssemblyFileVersion("0.4.1.0")]
[assembly: AssemblyInformationalVersion("0.4.1+ff1cdb186f76b7d41bda6fb07c33795e02baf157")]
[assembly: AssemblyProduct("RlValheimLink.Contract")]
[assembly: AssemblyTitle("RlValheimLink.Contract")]
[assembly: AssemblyVersion("0.4.1.0")]
namespace RlValheimLink.Contract;

public static class Bitset
{
	public static byte[] Pack(bool[] cells, int width, int height)
	{
		if (cells == null)
		{
			throw new ArgumentNullException("cells");
		}
		long num = (long)width * (long)height;
		if (cells.Length != num)
		{
			throw new ArgumentException($"expected {num} cells, got {cells.Length}");
		}
		byte[] array = new byte[Caps.BitmapBytes(width, height)];
		for (int i = 0; i < cells.Length; i++)
		{
			if (cells[i])
			{
				array[i >> 3] |= (byte)(1 << (i & 7));
			}
		}
		return array;
	}

	public static byte[] Pack(BitArray cells, int width, int height)
	{
		if (cells == null)
		{
			throw new ArgumentNullException("cells");
		}
		long num = (long)width * (long)height;
		if (cells.Length != num)
		{
			throw new ArgumentException($"expected {num} cells, got {cells.Length}");
		}
		byte[] array = new byte[Caps.BitmapBytes(width, height)];
		for (int i = 0; i < cells.Length; i++)
		{
			if (cells[i])
			{
				array[i >> 3] |= (byte)(1 << (i & 7));
			}
		}
		return array;
	}

	public static bool Any(BitArray cells)
	{
		if (cells == null)
		{
			return false;
		}
		for (int i = 0; i < cells.Length; i++)
		{
			if (cells[i])
			{
				return true;
			}
		}
		return false;
	}

	public static bool[] Unpack(byte[] bytes, int width, int height)
	{
		long num = (long)width * (long)height;
		if (bytes.Length != Caps.BitmapBytes(width, height))
		{
			throw new ArgumentException("wrong byte count for the mask");
		}
		bool[] array = new bool[num];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = (bytes[i >> 3] & (1 << (i & 7))) != 0;
		}
		return array;
	}

	public static string GzipBase64(byte[] raw)
	{
		using MemoryStream memoryStream = new MemoryStream();
		using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionLevel.Optimal, leaveOpen: true))
		{
			gZipStream.Write(raw, 0, raw.Length);
		}
		byte[] array = memoryStream.ToArray();
		if (array.Length >= 10 && array[0] == 31 && array[1] == 139 && array[2] == 8 && array[3] == 0)
		{
			array[4] = (array[5] = (array[6] = (array[7] = 0)));
			array[8] = 0;
			array[9] = 3;
		}
		return Convert.ToBase64String(array);
	}

	public static ExploredBitmap Encode(bool[] cells, int width, int height)
	{
		return new ExploredBitmap
		{
			Width = width,
			Height = height,
			Data = GzipBase64(Pack(cells, width, height))
		};
	}

	public static byte[] Decode(string base64, int width, int height)
	{
		byte[] array;
		try
		{
			array = Convert.FromBase64String(base64);
		}
		catch (FormatException innerException)
		{
			throw new InvalidDataException("bad base64", innerException);
		}
		int num = Caps.BitmapBytes(width, height);
		if (array.Length < 18)
		{
			throw new InvalidDataException("gzip too short");
		}
		if (array[0] != 31 || array[1] != 139 || array[2] != 8)
		{
			throw new InvalidDataException("not a gzip member");
		}
		if (array[3] != 0)
		{
			throw new InvalidDataException("gzip FLG must be 0");
		}
		if (array.Length > Caps.BitmapMaxGzipBytes(width, height))
		{
			throw new InvalidDataException("compressed bitmap over the size-tied cap");
		}
		byte[] array2 = new byte[num];
		using (MemoryStream memoryStream = new MemoryStream(array, 10, array.Length - 18, writable: false))
		{
			using DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionMode.Decompress);
			int num2 = ReadFully(deflateStream, array2);
			if (num2 != num)
			{
				throw new InvalidDataException($"inflated {num2} bytes, expected {num}");
			}
			byte[] buffer = new byte[1];
			if (deflateStream.Read(buffer, 0, 1) != 0)
			{
				throw new InvalidDataException("inflated output over the limit");
			}
			if (memoryStream.Position != memoryStream.Length)
			{
				throw new InvalidDataException("trailing bytes after the deflate stream (second gzip member?)");
			}
		}
		uint num3 = BitConverter.ToUInt32(array, array.Length - 8);
		if (BitConverter.ToUInt32(array, array.Length - 4) != (uint)num)
		{
			throw new InvalidDataException("gzip ISIZE trailer mismatch");
		}
		if (num3 != Crc32.Compute(array2))
		{
			throw new InvalidDataException("gzip CRC mismatch");
		}
		return array2;
	}

	private static int ReadFully(Stream s, byte[] buf)
	{
		int i;
		int num;
		for (i = 0; i < buf.Length; i += num)
		{
			num = s.Read(buf, i, buf.Length - i);
			if (num <= 0)
			{
				break;
			}
		}
		return i;
	}
}
public static class Crc32
{
	private static readonly uint[] Table = BuildTable();

	private static uint[] BuildTable()
	{
		uint[] array = new uint[256];
		for (uint num = 0u; num < 256; num++)
		{
			uint num2 = num;
			for (int i = 0; i < 8; i++)
			{
				num2 = (((num2 & 1) != 0) ? (0xEDB88320u ^ (num2 >> 1)) : (num2 >> 1));
			}
			array[num] = num2;
		}
		return array;
	}

	public static uint Compute(byte[] data)
	{
		return Update(uint.MaxValue, data, 0, data.Length) ^ 0xFFFFFFFFu;
	}

	public static uint Update(uint crc, byte[] data, int offset, int count)
	{
		for (int i = offset; i < offset + count; i++)
		{
			crc = Table[(crc ^ data[i]) & 0xFF] ^ (crc >> 8);
		}
		return crc;
	}
}
public static class Caps
{
	public const int SchemaVersion = 1;

	public const int CharacterMaxBytes = 2097152;

	public const int MapMaxBytes = 8388608;

	public const int ItemsMaxBytes = 12582912;

	public const int ContainersMaxBytes = 10485760;

	public const int RecipesMaxBytes = 12582912;

	public const int BinaryMaxBytes = 16777216;

	public const int BitmapDataMaxChars = 3000000;

	public const int BitmapDataMinChars = 28;

	public const int BitmapEdgeMin = 64;

	public const int BitmapEdgeMax = 4096;

	public const int EquipmentMax = 32;

	public const int InventoryItemsMax = 512;

	public const int GridEdgeMax = 32;

	public const int VanillaRows = 4;

	public const int SkillsMax = 128;

	public const int TrophiesMax = 1024;

	public const int KnownMax = 8192;

	public const int PinsMax = 2000;

	public const int ItemExportMax = 10000;

	public const int ItemExportMin = 1;

	public const int ContainersMax = 4096;

	public const int ContainerItemsMax = 256;

	public const int ContainerSlotsMax = 4096;

	public const int ContainerEntriesMax = 50000;

	public const int RecipesMax = 4096;

	public const int PiecesMax = 4096;

	public const int StationsMax = 256;

	public const int ProcessorsMax = 256;

	public const int ProcessesMax = 2048;

	public const int RequirementsMax = 16;

	public const int ProcessInputsMax = 8;

	public const int RecipeEntriesMax = 12000;

	public const int StationLevelMax = 20;

	public const int TimestampMaxChars = 24;

	public const int WorldCoordMax = 32768;

	public const int BinaryEdgeMax = 16384;

	public const string SteamId64Min = "76561197960265728";

	public const string Int64Min = "-9223372036854775808";

	public const string Int64Max = "9223372036854775807";

	public static int BitmapBytes(int width, int height)
	{
		return (int)(((long)width * (long)height + 7) / 8);
	}

	public static int BitmapMaxGzipBytes(int width, int height)
	{
		int num = BitmapBytes(width, height);
		return num + (num + 7) / 8 + (num + 63) / 64 + 64;
	}

	public static int BitmapMaxDataChars(int width, int height)
	{
		int num = BitmapMaxGzipBytes(width, height);
		return 4 * ((num + 2) / 3);
	}

	public static int BodyCapFor(string kind)
	{
		return kind switch
		{
			"character" => 2097152, 
			"map" => 8388608, 
			"items" => 12582912, 
			"containers" => 10485760, 
			"recipes" => 12582912, 
			_ => 0, 
		};
	}
}
public static class MessageJson
{
	public static readonly UTF8Encoding Utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);

	private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
	{
		Formatting = (Formatting)0,
		NullValueHandling = (NullValueHandling)0,
		DefaultValueHandling = (DefaultValueHandling)0,
		FloatFormatHandling = (FloatFormatHandling)1,
		DateParseHandling = (DateParseHandling)0,
		Culture = CultureInfo.InvariantCulture
	};

	private static readonly JsonLoadSettings ParseSettings = new JsonLoadSettings
	{
		DuplicatePropertyNameHandling = (DuplicatePropertyNameHandling)2,
		CommentHandling = (CommentHandling)0,
		LineInfoHandling = (LineInfoHandling)0
	};

	public static string Serialize(LinkMessage message)
	{
		return JsonConvert.SerializeObject((object)message, Settings);
	}

	public static byte[] SerializeToBytes(LinkMessage message)
	{
		return Utf8NoBom.GetBytes(Serialize(message));
	}

	public static JObject ToToken(LinkMessage message)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		return (JObject)Parse(Serialize(message));
	}

	public static JToken Parse(string json)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		using StringReader stringReader = new StringReader(json);
		JsonTextReader val = new JsonTextReader((TextReader)stringReader)
		{
			DateParseHandling = (DateParseHandling)0,
			FloatParseHandling = (FloatParseHandling)0
		};
		try
		{
			JToken result = JToken.ReadFrom((JsonReader)(object)val, ParseSettings);
			if (((JsonReader)val).Read())
			{
				throw new JsonReaderException("trailing content after the JSON value");
			}
			return result;
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	public static JToken Parse(byte[] utf8)
	{
		return Parse(Utf8NoBom.GetString(utf8));
	}

	public static byte[] ToBytes(JToken token)
	{
		return Utf8NoBom.GetBytes(token.ToString((Formatting)0, Array.Empty<JsonConverter>()));
	}

	public static string Timestamp(DateTime utc)
	{
		return utc.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);
	}

	public static bool TryParseTimestamp(string s, out DateTime utc)
	{
		return DateTime.TryParseExact(s, new string[4] { "yyyy-MM-dd'T'HH:mm:ss'Z'", "yyyy-MM-dd'T'HH:mm:ss.f'Z'", "yyyy-MM-dd'T'HH:mm:ss.ff'Z'", "yyyy-MM-dd'T'HH:mm:ss.fff'Z'" }, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out utc);
	}
}
public abstract class LinkMessage
{
	[JsonProperty("schemaVersion", Order = 0)]
	public int SchemaVersion { get; set; } = 1;

	[JsonProperty("serverId", Order = 1)]
	public string ServerId { get; set; }

	[JsonProperty("capturedAt", Order = 2)]
	public string CapturedAt { get; set; }

	[JsonProperty("gameVersion", Order = 3)]
	public string GameVersion { get; set; }

	[JsonProperty("modVersion", Order = 4)]
	public string ModVersion { get; set; }

	[JsonProperty("kind", Order = 5)]
	public abstract string Kind { get; }
}
public sealed class CharacterMessage : LinkMessage
{
	public override string Kind => "character";

	[JsonProperty("character", Order = 10)]
	public CharacterIdentity Character { get; set; } = new CharacterIdentity();

	[JsonProperty("equipment", Order = 11)]
	public List<EquippedItem> Equipment { get; set; } = new List<EquippedItem>();

	[JsonProperty("inventory", Order = 12)]
	public Inventory Inventory { get; set; } = new Inventory();

	[JsonProperty("skills", Order = 13)]
	public List<Skill> Skills { get; set; } = new List<Skill>();

	[JsonProperty("trophies", Order = 14)]
	public List<string> Trophies { get; set; } = new List<string>();

	[JsonProperty("knownItems", Order = 15)]
	public List<string> KnownItems { get; set; } = new List<string>();

	[JsonProperty("knownRecipes", Order = 16)]
	public List<string> KnownRecipes { get; set; } = new List<string>();
}
public sealed class CharacterIdentity
{
	[JsonProperty("steamId", Order = 0)]
	public string SteamId { get; set; }

	[JsonProperty("playerId", Order = 1)]
	public string PlayerId { get; set; }

	[JsonProperty("name", Order = 2)]
	public string Name { get; set; }

	[JsonProperty("worldUid", Order = 3)]
	public string WorldUid { get; set; }

	[JsonProperty("worldName", Order = 4)]
	public string WorldName { get; set; }
}
public sealed class ItemStack
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("stack", Order = 1)]
	public int Stack { get; set; }

	[JsonProperty("quality", Order = 2)]
	public int Quality { get; set; }

	[JsonProperty("variant", Order = 3)]
	public int Variant { get; set; }

	[JsonProperty("durability", Order = 4)]
	public double? Durability { get; set; }

	[JsonProperty("maxDurability", Order = 5)]
	public double? MaxDurability { get; set; }
}
public static class EquipSlot
{
	public const string Head = "head";

	public const string Chest = "chest";

	public const string Legs = "legs";

	public const string Shoulder = "shoulder";

	public const string Utility = "utility";

	public const string Trinket = "trinket";

	public const string RightHand = "rightHand";

	public const string LeftHand = "leftHand";

	public const string Ammo = "ammo";

	public static readonly string[] All = new string[9] { "head", "chest", "legs", "shoulder", "utility", "trinket", "rightHand", "leftHand", "ammo" };
}
public sealed class EquippedItem
{
	[JsonProperty("slot", Order = 0)]
	public string Slot { get; set; }

	[JsonProperty("item", Order = 1)]
	public ItemStack Item { get; set; }
}
public static class RowPurpose
{
	public const string Equipment = "equipment";

	public const string Quickslot = "quickslot";

	public const string Extended = "extended";

	public const string Other = "other";

	public static readonly string[] All = new string[4] { "equipment", "quickslot", "extended", "other" };
}
public sealed class GridExtraRow
{
	[JsonProperty("y", Order = 0)]
	public int Y { get; set; }

	[JsonProperty("purpose", Order = 1)]
	public string Purpose { get; set; }
}
public sealed class InventoryGrid
{
	[JsonProperty("width", Order = 0)]
	public int Width { get; set; }

	[JsonProperty("height", Order = 1)]
	public int Height { get; set; }

	[JsonProperty("extraRows", Order = 2)]
	public List<GridExtraRow> ExtraRows { get; set; } = new List<GridExtraRow>();
}
public sealed class InventorySlot
{
	[JsonProperty("x", Order = 0)]
	public int X { get; set; }

	[JsonProperty("y", Order = 1)]
	public int Y { get; set; }

	[JsonProperty("equipped", Order = 2)]
	public bool Equipped { get; set; }

	[JsonProperty("item", Order = 3)]
	public ItemStack Item { get; set; }
}
public sealed class Inventory
{
	[JsonProperty("grid", Order = 0)]
	public InventoryGrid Grid { get; set; } = new InventoryGrid();

	[JsonProperty("items", Order = 1)]
	public List<InventorySlot> Items { get; set; } = new List<InventorySlot>();
}
public sealed class Skill
{
	[JsonProperty("id", Order = 0)]
	public string Id { get; set; }

	[JsonProperty("level", Order = 1)]
	public double Level { get; set; }

	[JsonProperty("accumulator", Order = 2)]
	public double Accumulator { get; set; }
}
public sealed class MapMessage : LinkMessage
{
	public override string Kind => "map";

	[JsonProperty("character", Order = 10)]
	public MapCharacterRef Character { get; set; } = new MapCharacterRef();

	[JsonProperty("grid", Order = 11)]
	public MapGrid Grid { get; set; } = new MapGrid();

	[JsonProperty("explored", Order = 12)]
	public ExploredBitmap Explored { get; set; }

	[JsonProperty("sharedExplored", Order = 13)]
	public ExploredBitmap SharedExplored { get; set; }

	[JsonProperty("pins", Order = 14)]
	public List<MapPin> Pins { get; set; } = new List<MapPin>();

	[JsonProperty("baseMap", Order = 15)]
	public BinaryRef BaseMap { get; set; }
}
public sealed class MapCharacterRef
{
	[JsonProperty("steamId", Order = 0)]
	public string SteamId { get; set; }

	[JsonProperty("playerId", Order = 1)]
	public string PlayerId { get; set; }

	[JsonProperty("worldUid", Order = 2)]
	public string WorldUid { get; set; }
}
public sealed class MapGrid
{
	[JsonProperty("textureSize", Order = 0)]
	public int TextureSize { get; set; }

	[JsonProperty("pixelSizeMetres", Order = 1)]
	public double PixelSizeMetres { get; set; }
}
public sealed class ExploredBitmap
{
	public const string EncodingName = "gzip+base64-bitset-lsb0";

	[JsonProperty("encoding", Order = 0)]
	public string Encoding { get; set; } = "gzip+base64-bitset-lsb0";

	[JsonProperty("width", Order = 1)]
	public int Width { get; set; }

	[JsonProperty("height", Order = 2)]
	public int Height { get; set; }

	[JsonProperty("data", Order = 3)]
	public string Data { get; set; }
}
public sealed class MapPin
{
	[JsonProperty("type", Order = 0)]
	public string Type { get; set; }

	[JsonProperty("label", Order = 1)]
	public string Label { get; set; } = "";

	[JsonProperty("x", Order = 2)]
	public double X { get; set; }

	[JsonProperty("z", Order = 3)]
	public double Z { get; set; }

	[JsonProperty("checked", Order = 4)]
	public bool Checked { get; set; }

	[JsonProperty("shared", Order = 5)]
	public bool Shared { get; set; }
}
public sealed class BinaryRef
{
	[JsonProperty("sha256", Order = 0)]
	public string Sha256 { get; set; }

	[JsonProperty("byteLength", Order = 1)]
	public int ByteLength { get; set; }

	[JsonProperty("contentType", Order = 2)]
	public string ContentType { get; set; } = "image/png";

	[JsonProperty("width", Order = 3)]
	public int Width { get; set; }

	[JsonProperty("height", Order = 4)]
	public int Height { get; set; }
}
public sealed class ItemsMessage : LinkMessage
{
	public override string Kind => "items";

	[JsonProperty("locale", Order = 10)]
	public string Locale { get; set; }

	[JsonProperty("atlas", Order = 11)]
	public BinaryRef Atlas { get; set; }

	[JsonProperty("items", Order = 12)]
	public List<ItemDefinition> Items { get; set; } = new List<ItemDefinition>();
}
public sealed class ItemDefinition
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("name", Order = 1)]
	public string Name { get; set; }

	[JsonProperty("category", Order = 2)]
	public string Category { get; set; }

	[JsonProperty("maxStack", Order = 3)]
	public int MaxStack { get; set; }

	[JsonProperty("maxQuality", Order = 4)]
	public int MaxQuality { get; set; }

	[JsonProperty("variants", Order = 5)]
	public int Variants { get; set; }

	[JsonProperty("icon", Order = 6)]
	public ItemIcon Icon { get; set; }
}
public sealed class ItemIcon
{
	[JsonProperty("kind", Order = 0)]
	public string Kind { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public int? X { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public int? Y { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public int? W { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public int? H { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public string File { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public BinaryRef Blob { get; set; }

	public static ItemIcon Atlas(int x, int y, int w, int h)
	{
		return new ItemIcon
		{
			Kind = "atlas",
			X = x,
			Y = y,
			W = w,
			H = h
		};
	}

	public static ItemIcon FromFile(string file, BinaryRef blob = null)
	{
		return new ItemIcon
		{
			Kind = "file",
			File = file,
			Blob = blob
		};
	}
}
public sealed class ContainersMessage : LinkMessage
{
	public override string Kind => "containers";

	[JsonProperty("worldUid", Order = 10)]
	public string WorldUid { get; set; }

	[JsonProperty("containers", Order = 11)]
	public List<ContainerSnapshot> Containers { get; set; } = new List<ContainerSnapshot>();

	[JsonProperty("omittedShared", Order = 12)]
	public int OmittedShared { get; set; }

	[JsonProperty("omittedPrivate", Order = 13)]
	public int OmittedPrivate { get; set; }
}
public static class ContainerPrivacy
{
	public const string Public = "public";

	public const string Private = "private";

	public const string Group = "group";

	public static readonly string[] All = new string[3] { "public", "private", "group" };
}
public sealed class ContainerSnapshot
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("x", Order = 1)]
	public double X { get; set; }

	[JsonProperty("y", Order = 2)]
	public double Y { get; set; }

	[JsonProperty("z", Order = 3)]
	public double Z { get; set; }

	[JsonProperty("creatorPlayerId", Order = 4)]
	public string CreatorPlayerId { get; set; }

	[JsonProperty("privacy", Order = 5)]
	public string Privacy { get; set; } = "public";

	[JsonProperty("vehicle", Order = 6)]
	public bool Vehicle { get; set; }

	[JsonProperty("slots", Order = 7)]
	public int Slots { get; set; }

	[JsonProperty("usedSlots", Order = 8)]
	public int UsedSlots { get; set; }

	[JsonProperty("unreadable", Order = 9)]
	public bool Unreadable { get; set; }

	[JsonProperty("omittedEntries", Order = 10)]
	public int OmittedEntries { get; set; }

	[JsonProperty("items", Order = 11)]
	public List<ContainerStack> Items { get; set; } = new List<ContainerStack>();
}
public sealed class ContainerStack
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("quality", Order = 1)]
	public int Quality { get; set; }

	[JsonProperty("stack", Order = 2)]
	public int Stack { get; set; }
}
public sealed class RecipesMessage : LinkMessage
{
	public override string Kind => "recipes";

	[JsonProperty("locale", Order = 10)]
	public string Locale { get; set; }

	[JsonProperty("atlas", Order = 11)]
	public BinaryRef Atlas { get; set; }

	[JsonProperty("stations", Order = 12)]
	public List<CraftingStationDef> Stations { get; set; } = new List<CraftingStationDef>();

	[JsonProperty("recipes", Order = 13)]
	public List<RecipeDef> Recipes { get; set; } = new List<RecipeDef>();

	[JsonProperty("pieces", Order = 14)]
	public List<PieceDef> Pieces { get; set; } = new List<PieceDef>();

	[JsonProperty("processors", Order = 15)]
	public List<ProcessorDef> Processors { get; set; } = new List<ProcessorDef>();

	[JsonProperty("processes", Order = 16)]
	public List<ProcessDef> Processes { get; set; } = new List<ProcessDef>();
}
public sealed class AtlasIcon
{
	[JsonProperty("kind", Order = 0)]
	public string Kind { get; set; } = "atlas";

	[JsonProperty("x", Order = 1)]
	public int X { get; set; }

	[JsonProperty("y", Order = 2)]
	public int Y { get; set; }

	[JsonProperty("w", Order = 3)]
	public int W { get; set; }

	[JsonProperty("h", Order = 4)]
	public int H { get; set; }
}
public sealed class CraftingStationDef
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("name", Order = 1)]
	public string Name { get; set; }

	[JsonProperty("maxLevel", Order = 2)]
	public int MaxLevel { get; set; } = 1;

	[JsonProperty("stackableExtension", Order = 3)]
	public bool StackableExtension { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public bool? Upgrader { get; set; }

	[JsonProperty("icon", Order = 5)]
	public AtlasIcon Icon { get; set; }
}
public static class RecipeFormula
{
	public const string Vanilla = "vanilla";

	public const string Custom = "custom";
}
public sealed class RecipeDef
{
	[JsonProperty("id", Order = 0)]
	public string Id { get; set; }

	[JsonProperty("result", Order = 1)]
	public string Result { get; set; }

	[JsonProperty("amount", Order = 2)]
	public int Amount { get; set; } = 1;

	[JsonProperty("enabled", Order = 3)]
	public bool Enabled { get; set; } = true;

	[JsonProperty("station", Order = 4)]
	public string Station { get; set; }

	[JsonProperty("repairStation", Order = 5)]
	public string RepairStation { get; set; }

	[JsonProperty("minStationLevel", Order = 6)]
	public int MinStationLevel { get; set; }

	[JsonProperty("upgradeOnly", Order = 7)]
	public bool UpgradeOnly { get; set; }

	[JsonProperty("anyOneOf", Order = 8)]
	public bool AnyOneOf { get; set; }

	[JsonProperty("qualityResultAmountMultiplier", Order = 9)]
	public double QualityResultAmountMultiplier { get; set; } = 1.0;

	[JsonProperty("formula", Order = 10)]
	public string Formula { get; set; } = "vanilla";

	[JsonProperty("resources", Order = 11)]
	public List<RecipeResource> Resources { get; set; } = new List<RecipeResource>();
}
public sealed class RecipeResource
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("amount", Order = 1)]
	public int Amount { get; set; }

	[JsonProperty("amountPerLevel", Order = 2)]
	public int AmountPerLevel { get; set; }

	[JsonProperty("extraAmountOnlyOneIngredient", Order = 3)]
	public int ExtraAmountOnlyOneIngredient { get; set; }

	[JsonProperty("recover", Order = 4)]
	public bool Recover { get; set; }

	[JsonProperty(/*Could not decode attribute arguments.*/)]
	public bool? UpgraderResource { get; set; }
}
public sealed class PieceDef
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("name", Order = 1)]
	public string Name { get; set; }

	[JsonProperty("category", Order = 2)]
	public string Category { get; set; }

	[JsonProperty("tool", Order = 3)]
	public string Tool { get; set; }

	[JsonProperty("station", Order = 4)]
	public string Station { get; set; }

	[JsonProperty("icon", Order = 5)]
	public AtlasIcon Icon { get; set; }

	[JsonProperty("resources", Order = 6)]
	public List<PieceResource> Resources { get; set; } = new List<PieceResource>();
}
public sealed class PieceResource
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("amount", Order = 1)]
	public int Amount { get; set; }

	[JsonProperty("recover", Order = 2)]
	public bool Recover { get; set; }
}
public static class ProcessorType
{
	public const string Smelter = "smelter";

	public const string Fermenter = "fermenter";

	public const string Cooking = "cooking";

	public const string Incinerator = "incinerator";
}
public sealed class ProcessorDef
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("type", Order = 1)]
	public string Type { get; set; }

	[JsonProperty("fuel", Order = 2)]
	public string Fuel { get; set; }

	[JsonProperty("fuelPerProduct", Order = 3)]
	public int? FuelPerProduct { get; set; }

	[JsonProperty("fuelSecondsPerUnit", Order = 4)]
	public double? FuelSecondsPerUnit { get; set; }

	[JsonProperty("windPowered", Order = 5)]
	public bool WindPowered { get; set; }

	[JsonProperty("requiresRoof", Order = 6)]
	public bool RequiresRoof { get; set; }

	[JsonProperty("maxInput", Order = 7)]
	public int? MaxInput { get; set; }

	[JsonProperty("burntResult", Order = 8)]
	public string BurntResult { get; set; }

	[JsonProperty("defaultResult", Order = 9)]
	public ProcessorDefaultResult DefaultResult { get; set; }
}
public sealed class ProcessorDefaultResult
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("perInputs", Order = 1)]
	public int PerInputs { get; set; }
}
public sealed class ProcessDef
{
	[JsonProperty("processor", Order = 0)]
	public string Processor { get; set; }

	[JsonProperty("inputs", Order = 1)]
	public List<PrefabAmount> Inputs { get; set; } = new List<PrefabAmount>();

	[JsonProperty("anyOneOf", Order = 2)]
	public bool AnyOneOf { get; set; }

	[JsonProperty("output", Order = 3)]
	public PrefabAmount Output { get; set; }

	[JsonProperty("seconds", Order = 4)]
	public double? Seconds { get; set; }

	[JsonProperty("priority", Order = 5)]
	public int Priority { get; set; }
}
public sealed class PrefabAmount
{
	[JsonProperty("prefab", Order = 0)]
	public string Prefab { get; set; }

	[JsonProperty("amount", Order = 1)]
	public int Amount { get; set; }
}
public static class Png
{
	private static readonly byte[] Signature = new byte[8] { 137, 80, 78, 71, 13, 10, 26, 10 };

	public static byte[] EncodeRgba(byte[] rgba, int width, int height)
	{
		if (width <= 0 || height <= 0)
		{
			throw new ArgumentOutOfRangeException("width");
		}
		if (rgba.Length != (long)width * (long)height * 4)
		{
			throw new ArgumentException("rgba length must be width*height*4");
		}
		int num = width * 4;
		byte[] array = new byte[(num + 1) * height];
		for (int i = 0; i < height; i++)
		{
			int num2 = i * num;
			int num3 = i * (num + 1);
			array[num3] = 2;
			if (i == 0)
			{
				Buffer.BlockCopy(rgba, num2, array, num3 + 1, num);
				continue;
			}
			for (int j = 0; j < num; j++)
			{
				array[num3 + 1 + j] = (byte)(rgba[num2 + j] - rgba[num2 - num + j]);
			}
		}
		byte[] data = ZlibCompress(array);
		using MemoryStream memoryStream = new MemoryStream();
		memoryStream.Write(Signature, 0, Signature.Length);
		byte[] array2 = new byte[13];
		WriteBE(array2, 0, (uint)width);
		WriteBE(array2, 4, (uint)height);
		array2[8] = 8;
		array2[9] = 6;
		array2[10] = 0;
		array2[11] = 0;
		array2[12] = 0;
		WriteChunk(memoryStream, "IHDR", array2);
		WriteChunk(memoryStream, "IDAT", data);
		WriteChunk(memoryStream, "IEND", new byte[0]);
		return memoryStream.ToArray();
	}

	public static bool TryReadSize(byte[] png, out int width, out int height)
	{
		width = (height = 0);
		if (png == null || png.Length < 33)
		{
			return false;
		}
		for (int i = 0; i < 8; i++)
		{
			if (png[i] != Signature[i])
			{
				return false;
			}
		}
		if (ReadBE(png, 8) != 13)
		{
			return false;
		}
		if (png[12] != 73 || png[13] != 72 || png[14] != 68 || png[15] != 82)
		{
			return false;
		}
		uint num = ReadBE(png, 16);
		uint num2 = ReadBE(png, 20);
		if (num == 0 || num2 == 0 || num > int.MaxValue || num2 > int.MaxValue)
		{
			return false;
		}
		width = (int)num;
		height = (int)num2;
		return true;
	}

	public static BinaryRef MakeRef(byte[] png)
	{
		if (!TryReadSize(png, out var width, out var height))
		{
			throw new InvalidDataException("not a PNG");
		}
		return new BinaryRef
		{
			Sha256 = Sha256Hex(png),
			ByteLength = png.Length,
			ContentType = "image/png",
			Width = width,
			Height = height
		};
	}

	public static string Sha256Hex(byte[] data)
	{
		using SHA256 sHA = SHA256.Create();
		byte[] array = sHA.ComputeHash(data);
		StringBuilder stringBuilder = new StringBuilder(64);
		byte[] array2 = array;
		foreach (byte b in array2)
		{
			stringBuilder.Append(b.ToString("x2"));
		}
		return stringBuilder.ToString();
	}

	private static byte[] ZlibCompress(byte[] data)
	{
		using MemoryStream memoryStream = new MemoryStream();
		memoryStream.WriteByte(120);
		memoryStream.WriteByte(156);
		using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal, leaveOpen: true))
		{
			deflateStream.Write(data, 0, data.Length);
		}
		uint num = 1u;
		uint num2 = 0u;
		foreach (byte b in data)
		{
			num = (num + b) % 65521;
			num2 = (num2 + num) % 65521;
		}
		byte[] array = new byte[4];
		WriteBE(array, 0, (num2 << 16) | num);
		memoryStream.Write(array, 0, 4);
		return memoryStream.ToArray();
	}

	private static void WriteChunk(Stream s, string type, byte[] data)
	{
		byte[] array = new byte[4];
		WriteBE(array, 0, (uint)data.Length);
		s.Write(array, 0, 4);
		byte[] bytes = Encoding.ASCII.GetBytes(type);
		s.Write(bytes, 0, 4);
		s.Write(data, 0, data.Length);
		uint crc = Crc32.Update(uint.MaxValue, bytes, 0, 4);
		crc = Crc32.Update(crc, data, 0, data.Length) ^ 0xFFFFFFFFu;
		byte[] array2 = new byte[4];
		WriteBE(array2, 0, crc);
		s.Write(array2, 0, 4);
	}

	private static void WriteBE(byte[] b, int o, uint v)
	{
		b[o] = (byte)(v >> 24);
		b[o + 1] = (byte)(v >> 16);
		b[o + 2] = (byte)(v >> 8);
		b[o + 3] = (byte)v;
	}

	private static uint ReadBE(byte[] b, int o)
	{
		return (uint)((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]);
	}
}
public sealed class ValidationIssue
{
	public string Path { get; }

	public string Code { get; }

	public string Message { get; }

	public ValidationIssue(string path, string code, string message)
	{
		Path = path;
		Code = code;
		Message = message;
	}

	public override string ToString()
	{
		return ((Path.Length == 0) ? "<root>" : Path) + ": " + Code + " (" + Message + ")";
	}
}
public static class Validator
{
	private sealed class AtlasCheck
	{
		public bool HasAtlas;

		public bool Any;

		public int Width;

		public int Height;
	}

	private static readonly Regex ServerId = new Regex("^[A-Za-z0-9_-]{1,64}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex GameVersion = new Regex("^\\d{1,4}(\\.\\d{1,5}){1,3}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex SemVer = new Regex("^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?\\z", RegexOptions.CultureInvariant);

	private static readonly Regex IsoDateTime = new Regex("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?Z\\z", RegexOptions.CultureInvariant);

	private static readonly Regex SteamId = new Regex("^[1-9]\\d{16}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex Int64 = new Regex("^(0|-?[1-9]\\d{0,18})\\z", RegexOptions.CultureInvariant);

	private static readonly Regex Prefab = new Regex("^[A-Za-z0-9_.-]{1,96}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex Sha256 = new Regex("^[0-9a-f]{64}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex SkillId = new Regex("^-?[A-Za-z0-9_]{1,64}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex PinType = new Regex("^[A-Za-z0-9_]{1,32}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex Category = new Regex("^[A-Za-z0-9_]{1,48}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex Locale = new Regex("^[A-Za-z_-]{2,32}\\z", RegexOptions.CultureInvariant);

	private static readonly Regex IconFile = new Regex("^[A-Za-z0-9_.-]{1,100}\\.png\\z", RegexOptions.CultureInvariant);

	private static readonly Regex BitmapData = new Regex("^H4sI[A-Za-z0-9+/]*={0,2}\\z", RegexOptions.CultureInvariant);

	private static readonly BigInteger SteamMin = BigInteger.Parse("76561197960265728", CultureInfo.InvariantCulture);

	private static readonly BigInteger I64Min = BigInteger.Parse("-9223372036854775808", CultureInfo.InvariantCulture);

	private static readonly BigInteger I64Max = BigInteger.Parse("9223372036854775807", CultureInfo.InvariantCulture);

	private static readonly string[] HeaderKeys = new string[6] { "schemaVersion", "serverId", "capturedAt", "gameVersion", "modVersion", "kind" };

	private static readonly string[] ContainerPrivacy = new string[3] { "public", "private", "group" };

	private static readonly string[] ProcessorTypes = new string[4] { "smelter", "fermenter", "cooking", "incinerator" };

	private static readonly string[] Formulas = new string[2] { "vanilla", "custom" };

	public static List<ValidationIssue> Validate(LinkMessage message)
	{
		return Validate((JToken)(object)MessageJson.ToToken(message));
	}

	public static List<ValidationIssue> Validate(string json)
	{
		try
		{
			return Validate(MessageJson.Parse(json));
		}
		catch (Exception ex)
		{
			return new List<ValidationIssue>
			{
				new ValidationIssue("", "invalid_type", "not JSON: " + ex.Message)
			};
		}
	}

	public static List<ValidationIssue> Validate(JToken root)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Invalid comparison between Unknown and I4
		List<ValidationIssue> list = new List<ValidationIssue>();
		JObject val = (JObject)(object)((root is JObject) ? root : null);
		if (val == null)
		{
			list.Add(new ValidationIssue("", "invalid_type", "message must be an object"));
			return list;
		}
		JToken obj = val["kind"];
		JToken obj2 = ((obj is JValue) ? obj : null);
		string text = ((obj2 != null && (int)obj2.Type == 8) ? ((string)val["kind"]) : null);
		if (text != "character" && text != "map" && text != "items" && text != "containers" && text != "recipes")
		{
			list.Add(new ValidationIssue("kind", "invalid_union", "kind must be character, map, items, containers or recipes"));
			return list;
		}
		switch (text)
		{
		case "character":
			Character(val, list);
			break;
		case "map":
			Map(val, list);
			break;
		case "items":
			Items(val, list);
			break;
		case "containers":
			Containers(val, list);
			break;
		case "recipes":
			Recipes(val, list);
			break;
		}
		return list;
	}

	private static void Header(JObject o, List<ValidationIssue> issues)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Invalid comparison between Unknown and I4
		JToken val = o["schemaVersion"];
		if (val == null || ((int)val.Type != 6 && (int)val.Type != 7) || (double)val != 1.0)
		{
			issues.Add(new ValidationIssue("schemaVersion", "invalid_value", "schemaVersion must be 1"));
		}
		Str(o, "serverId", "", issues, 0, null, ServerId);
		if (Str(o, "capturedAt", "", issues, 1, null, null, out var value))
		{
			if (!IsoDateTime.IsMatch(value))
			{
				issues.Add(new ValidationIssue("capturedAt", "invalid_format", "ISO-8601 UTC with Z"));
			}
			if (value.Length > 24)
			{
				issues.Add(new ValidationIssue("capturedAt", "too_big", "at most 3 fractional digits"));
			}
		}
		Str(o, "gameVersion", "", issues, 0, null, GameVersion);
		if (Str(o, "modVersion", "", issues, 1, null, null, out var value2))
		{
			if (value2.Length > 64)
			{
				issues.Add(new ValidationIssue("modVersion", "too_big", "at most 64 chars"));
			}
			else if (!SemVer.IsMatch(value2))
			{
				issues.Add(new ValidationIssue("modVersion", "invalid_format", "SemVer 2.0.0"));
			}
		}
	}

	private static void Character(JObject o, List<ValidationIssue> issues)
	{
		//IL_0501: Unknown result type (might be due to invalid IL or missing references)
		//IL_051d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0523: Invalid comparison between Unknown and I4
		Keys(o, "", issues, HeaderKeys, "character", "equipment", "inventory", "skills", "trophies", "knownItems", "knownRecipes");
		Header(o, issues);
		if (Obj(o, "character", "", issues, out var o2))
		{
			Keys(o2, "character", issues, "steamId", "playerId", "name", "worldUid", "worldName");
			SteamId64(o2, "steamId", "character", issues);
			Int64Str(o2, "playerId", "character", issues);
			Str(o2, "name", "character", issues, 1, 32, null);
			Int64Str(o2, "worldUid", "character", issues);
			Str(o2, "worldName", "character", issues, 1, 64, null);
		}
		if (Arr(o, "equipment", "", issues, 0, 32, out var a))
		{
			HashSet<string> hashSet = new HashSet<string>();
			for (int i = 0; i < ((JContainer)a).Count; i++)
			{
				string text = "equipment." + i;
				if (ObjAt(a[i], text, issues, out var o3))
				{
					Keys(o3, text, issues, "slot", "item");
					if (Enum(o3, "slot", text, issues, EquipSlot.All, out var value) && !hashSet.Add(value))
					{
						issues.Add(new ValidationIssue(text, "custom", "duplicate equipment entry"));
					}
					if (Obj(o3, "item", text, issues, out var o4))
					{
						ItemStack(o4, text + ".item", issues);
					}
				}
			}
		}
		if (Obj(o, "inventory", "", issues, out var o5))
		{
			Keys(o5, "inventory", issues, "grid", "items");
			int value2 = 0;
			int value3 = 0;
			bool flag = false;
			JArray a2 = null;
			if (Obj(o5, "grid", "inventory", issues, out var o6))
			{
				Keys(o6, "inventory.grid", issues, "width", "height", "extraRows");
				bool num = Int(o6, "width", "inventory.grid", issues, 1L, 32L, out value2);
				bool flag2 = Int(o6, "height", "inventory.grid", issues, 1L, 32L, out value3);
				flag = num && flag2;
				if (Arr(o6, "extraRows", "inventory.grid", issues, 0, 32, out a2))
				{
					for (int j = 0; j < ((JContainer)a2).Count; j++)
					{
						string path = "inventory.grid.extraRows." + j;
						if (!ObjAt(a2[j], path, issues, out var o7))
						{
							a2 = null;
							continue;
						}
						Keys(o7, path, issues, "y", "purpose");
						Int(o7, "y", path, issues, 0L, 31L, out var _);
						Enum(o7, "purpose", path, issues, RowPurpose.All, out var _);
					}
				}
			}
			if (Arr(o5, "items", "inventory", issues, 0, 512, out var a3))
			{
				HashSet<string> hashSet2 = new HashSet<string>();
				for (int k = 0; k < ((JContainer)a3).Count; k++)
				{
					string text2 = "inventory.items." + k;
					if (!ObjAt(a3[k], text2, issues, out var o8))
					{
						continue;
					}
					Keys(o8, text2, issues, "x", "y", "equipped", "item");
					int value6;
					bool flag3 = Int(o8, "x", text2, issues, 0L, 31L, out value6);
					int value7;
					bool flag4 = Int(o8, "y", text2, issues, 0L, 31L, out value7);
					Bool(o8, "equipped", text2, issues);
					if (Obj(o8, "item", text2, issues, out var o9))
					{
						ItemStack(o9, text2 + ".item", issues);
					}
					if (flag && flag3 && flag4)
					{
						if (value6 >= value2 || value7 >= value3)
						{
							issues.Add(new ValidationIssue(text2, "custom", "slot outside grid"));
						}
						else if (!hashSet2.Add(value6 + "," + value7))
						{
							issues.Add(new ValidationIssue(text2, "custom", "duplicate slot"));
						}
					}
				}
			}
			if (flag && a2 != null)
			{
				HashSet<int> hashSet3 = new HashSet<int>();
				bool flag5 = false;
				for (int l = 0; l < ((JContainer)a2).Count; l++)
				{
					JToken obj = ((JObject)a2[l])["y"];
					JValue val = (JValue)(object)((obj is JValue) ? obj : null);
					if (val == null || (int)((JToken)val).Type != 6)
					{
						flag5 = true;
						continue;
					}
					int num2 = (int)(JToken)(object)val;
					string text3 = ((num2 < 4) ? "row is a vanilla row" : ((num2 >= value3) ? "row outside grid" : ((!hashSet3.Add(num2)) ? "duplicate row" : null)));
					if (text3 != null)
					{
						flag5 = true;
						issues.Add(new ValidationIssue("inventory.grid.extraRows." + l, "custom", text3));
					}
				}
				int num3 = Math.Max(0, value3 - 4);
				if (!flag5 && ((JContainer)a2).Count != num3)
				{
					issues.Add(new ValidationIssue("inventory.grid.extraRows", "custom", $"every row past the vanilla four must be listed ({num3})"));
				}
			}
		}
		if (Arr(o, "skills", "", issues, 0, 128, out var a4))
		{
			HashSet<string> hashSet4 = new HashSet<string>();
			for (int m = 0; m < ((JContainer)a4).Count; m++)
			{
				string path2 = "skills." + m;
				if (ObjAt(a4[m], path2, issues, out var o10))
				{
					Keys(o10, path2, issues, "id", "level", "accumulator");
					if (Str(o10, "id", path2, issues, 0, null, SkillId, out var value8) && !hashSet4.Add(value8))
					{
						issues.Add(new ValidationIssue(path2, "custom", "duplicate skills entry"));
					}
					Num(o10, "level", path2, issues, 0.0, 100.0);
					Num(o10, "accumulator", path2, issues, 0.0, 1000000.0);
				}
			}
		}
		PrefabList(o, "trophies", "", issues, 1024);
		PrefabList(o, "knownItems", "", issues, 8192);
		PrefabList(o, "knownRecipes", "", issues, 8192);
	}

	private static void ItemStack(JObject item, string path, List<ValidationIssue> issues)
	{
		Keys(item, path, issues, "prefab", "stack", "quality", "variant", "durability", "maxDurability");
		Str(item, "prefab", path, issues, 0, null, Prefab);
		Int(item, "stack", path, issues, 1L, 100000L, out var value);
		Int(item, "quality", path, issues, 1L, 10L, out value);
		Int(item, "variant", path, issues, 0L, 63L, out value);
		bool flag = NullableNum(item, "durability", path, issues, 0.0, 1000000.0);
		bool flag2 = NullableNum(item, "maxDurability", path, issues, 0.0, 1000000.0);
		if (item["durability"] != null && item["maxDurability"] != null && flag != flag2)
		{
			issues.Add(new ValidationIssue(path + ".maxDurability", "custom", "durability and maxDurability are null together"));
		}
	}

	private static void Map(JObject o, List<ValidationIssue> issues)
	{
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Invalid comparison between Unknown and I4
		//IL_0332: Unknown result type (might be due to invalid IL or missing references)
		//IL_0339: Invalid comparison between Unknown and I4
		Keys(o, "", issues, HeaderKeys, "character", "grid", "explored", "sharedExplored", "pins", "baseMap");
		Header(o, issues);
		if (Obj(o, "character", "", issues, out var o2))
		{
			Keys(o2, "character", issues, "steamId", "playerId", "worldUid");
			SteamId64(o2, "steamId", "character", issues);
			Int64Str(o2, "playerId", "character", issues);
			Int64Str(o2, "worldUid", "character", issues);
		}
		int value = 0;
		bool flag = false;
		if (Obj(o, "grid", "", issues, out var o3))
		{
			Keys(o3, "grid", issues, "textureSize", "pixelSizeMetres");
			flag = Int(o3, "textureSize", "grid", issues, 64L, 4096L, out value);
			Num(o3, "pixelSizeMetres", "grid", issues, double.Epsilon, 256.0);
		}
		if (Obj(o, "explored", "", issues, out var o4))
		{
			Bitmap(o4, "explored", issues, flag ? value : (-1));
		}
		JToken val = o["sharedExplored"];
		JObject o5;
		if (val == null)
		{
			issues.Add(new ValidationIssue("sharedExplored", "invalid_type", "required (nullable)"));
		}
		else if ((int)val.Type != 10 && ObjAt(val, "sharedExplored", issues, out o5))
		{
			Bitmap(o5, "sharedExplored", issues, flag ? value : (-1));
		}
		if (Arr(o, "pins", "", issues, 0, 2000, out var a))
		{
			for (int i = 0; i < ((JContainer)a).Count; i++)
			{
				string path = "pins." + i;
				if (ObjAt(a[i], path, issues, out var o6))
				{
					Keys(o6, path, issues, "type", "label", "x", "z", "checked", "shared");
					Str(o6, "type", path, issues, 0, null, PinType);
					Str(o6, "label", path, issues, 0, 64, null);
					Num(o6, "x", path, issues, -32768.0, 32768.0);
					Num(o6, "z", path, issues, -32768.0, 32768.0);
					Bool(o6, "checked", path, issues);
					Bool(o6, "shared", path, issues);
				}
			}
		}
		JToken val2 = o["baseMap"];
		JObject o7;
		int w = default(int);
		int h = default(int);
		if (val2 == null)
		{
			issues.Add(new ValidationIssue("baseMap", "invalid_type", "required (nullable)"));
		}
		else if ((int)val2.Type != 10 && ObjAt(val2, "baseMap", issues, out o7) && BinaryRef(o7, "baseMap", issues, out w, out h) && flag && (w != value || h != value))
		{
			issues.Add(new ValidationIssue("baseMap", "custom", "base map size must equal grid.textureSize"));
		}
	}

	private static void Bitmap(JObject b, string path, List<ValidationIssue> issues, int textureSize)
	{
		Keys(b, path, issues, "encoding", "width", "height", "data");
		Literal(b, "encoding", path, issues, "gzip+base64-bitset-lsb0");
		int value;
		bool flag = Int(b, "width", path, issues, 64L, 4096L, out value);
		int value2;
		bool flag2 = Int(b, "height", path, issues, 64L, 4096L, out value2);
		if (Str(b, "data", path, issues, 0, null, null, out var value3))
		{
			string path2 = path + ".data";
			if (value3.Length < 28)
			{
				issues.Add(new ValidationIssue(path2, "too_small", "at least 28 chars"));
			}
			if (value3.Length > 3000000)
			{
				issues.Add(new ValidationIssue(path2, "too_big", "at most 3000000 chars"));
			}
			if (!BitmapData.IsMatch(value3))
			{
				issues.Add(new ValidationIssue(path2, "invalid_format", "one gzip member (H4sI…), standard base64"));
			}
			if (value3.Length % 4 != 0)
			{
				issues.Add(new ValidationIssue(path2, "custom", "base64 length must be a multiple of 4"));
			}
			if (flag && flag2 && value3.Length > Caps.BitmapMaxDataChars(value, value2))
			{
				issues.Add(new ValidationIssue(path2, "custom", $"compressed bitmap exceeds {Caps.BitmapMaxDataChars(value, value2)} chars for {value}×{value2}"));
			}
		}
		if (flag && flag2 && textureSize > 0 && (value != textureSize || value2 != textureSize))
		{
			issues.Add(new ValidationIssue(path, "custom", "bitmap size must equal grid.textureSize"));
		}
	}

	private static bool BinaryRef(JObject b, string path, List<ValidationIssue> issues, out int w, out int h)
	{
		Keys(b, path, issues, "sha256", "byteLength", "contentType", "width", "height");
		Str(b, "sha256", path, issues, 0, null, Sha256);
		Int(b, "byteLength", path, issues, 1L, 16777216L, out var _);
		Literal(b, "contentType", path, issues, "image/png");
		bool num = Int(b, "width", path, issues, 1L, 16384L, out w);
		bool flag = Int(b, "height", path, issues, 1L, 16384L, out h);
		return num && flag;
	}

	private static void Items(JObject o, List<ValidationIssue> issues)
	{
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Invalid comparison between Unknown and I4
		//IL_0495: Unknown result type (might be due to invalid IL or missing references)
		//IL_049c: Invalid comparison between Unknown and I4
		//IL_0262: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: Invalid comparison between Unknown and I4
		//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ab: Invalid comparison between Unknown and I4
		Keys(o, "", issues, HeaderKeys, "locale", "atlas", "items");
		Header(o, issues);
		Str(o, "locale", "", issues, 0, null, Locale);
		bool flag = false;
		int w = 0;
		int h = 0;
		JToken val = o["atlas"];
		JObject o2;
		if (val == null)
		{
			issues.Add(new ValidationIssue("atlas", "invalid_type", "required (nullable)"));
		}
		else if ((int)val.Type != 10 && ObjAt(val, "atlas", issues, out o2))
		{
			flag = BinaryRef(o2, "atlas", issues, out w, out h);
		}
		bool flag2 = false;
		if (Arr(o, "items", "", issues, 1, 10000, out var a))
		{
			HashSet<string> hashSet = new HashSet<string>();
			for (int i = 0; i < ((JContainer)a).Count; i++)
			{
				string text = "items." + i;
				if (!ObjAt(a[i], text, issues, out var o3))
				{
					continue;
				}
				Keys(o3, text, issues, "prefab", "name", "category", "maxStack", "maxQuality", "variants", "icon");
				if (Str(o3, "prefab", text, issues, 0, null, Prefab, out var value) && !hashSet.Add(value))
				{
					issues.Add(new ValidationIssue(text + ".prefab", "custom", "duplicate prefab"));
				}
				Str(o3, "name", text, issues, 1, 96, null);
				Str(o3, "category", text, issues, 0, null, Category);
				Int(o3, "maxStack", text, issues, 1L, 100000L, out var value2);
				Int(o3, "maxQuality", text, issues, 1L, 10L, out value2);
				Int(o3, "variants", text, issues, 0L, 64L, out value2);
				JToken val2 = o3["icon"];
				if (val2 == null)
				{
					issues.Add(new ValidationIssue(text + ".icon", "invalid_type", "required (nullable)"));
				}
				else
				{
					if ((int)val2.Type == 10)
					{
						continue;
					}
					string text2 = text + ".icon";
					if (!ObjAt(val2, text2, issues, out var o4))
					{
						continue;
					}
					JToken obj = o4["kind"];
					JToken obj2 = ((obj is JValue) ? obj : null);
					string text3 = ((obj2 != null && (int)obj2.Type == 8) ? ((string)o4["kind"]) : null);
					if (text3 == "atlas")
					{
						flag2 = true;
						Keys(o4, text2, issues, "kind", "x", "y", "w", "h");
						int value3;
						bool flag3 = Int(o4, "x", text2, issues, 0L, 16383L, out value3);
						int value4;
						bool flag4 = Int(o4, "y", text2, issues, 0L, 16383L, out value4);
						int value5;
						bool flag5 = Int(o4, "w", text2, issues, 1L, 512L, out value5);
						int value6;
						bool flag6 = Int(o4, "h", text2, issues, 1L, 512L, out value6);
						if (flag && flag3 && flag4 && flag5 && flag6 && (value3 + value5 > w || value4 + value6 > h))
						{
							issues.Add(new ValidationIssue(text2, "custom", "icon outside atlas"));
						}
					}
					else if (text3 == "file")
					{
						Keys(o4, text2, issues, "kind", "file", "blob");
						Str(o4, "file", text2, issues, 0, null, IconFile);
						JToken val3 = o4["blob"];
						if (val3 != null && ObjAt(val3, text2 + ".blob", issues, out var o5))
						{
							BinaryRef(o5, text2 + ".blob", issues, out value2, out var _);
						}
					}
					else
					{
						issues.Add(new ValidationIssue(text2 + ".kind", "invalid_union", "icon kind must be atlas or file"));
					}
				}
			}
		}
		if (val != null && (int)val.Type == 10 && flag2)
		{
			issues.Add(new ValidationIssue("atlas", "custom", "atlas icon without an atlas"));
		}
	}

	private static void Containers(JObject o, List<ValidationIssue> issues)
	{
		Keys(o, "", issues, HeaderKeys, "worldUid", "containers", "omittedShared", "omittedPrivate");
		Header(o, issues);
		Int64Str(o, "worldUid", "", issues);
		int value10;
		if (Arr(o, "containers", "", issues, 0, 4096, out var a))
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			int num = 0;
			for (int i = 0; i < ((JContainer)a).Count; i++)
			{
				string text = "containers." + i;
				if (!ObjAt(a[i], text, issues, out var o2))
				{
					continue;
				}
				Keys(o2, text, issues, "prefab", "x", "y", "z", "creatorPlayerId", "privacy", "vehicle", "slots", "usedSlots", "unreadable", "omittedEntries", "items");
				string value;
				bool flag = Str(o2, "prefab", text, issues, 0, null, Prefab, out value);
				double value2;
				bool flag2 = Num(o2, "x", text, issues, -32768.0, 32768.0, out value2);
				double value3;
				bool flag3 = Num(o2, "y", text, issues, -32768.0, 32768.0, out value3);
				double value4;
				bool flag4 = Num(o2, "z", text, issues, -32768.0, 32768.0, out value4);
				string value5;
				bool flag5 = Int64Str(o2, "creatorPlayerId", text, issues, out value5);
				if (flag5 && value5 == "0")
				{
					issues.Add(new ValidationIssue(text + ".creatorPlayerId", "custom", "creatorPlayerId must not be 0"));
					flag5 = false;
				}
				Enum(o2, "privacy", text, issues, ContainerPrivacy, out var _);
				Bool(o2, "vehicle", text, issues);
				int value7;
				bool flag6 = Int(o2, "slots", text, issues, 1L, 4096L, out value7);
				int value8;
				bool flag7 = Int(o2, "usedSlots", text, issues, 0L, 4096L, out value8);
				bool value9;
				bool flag8 = Bool(o2, "unreadable", text, issues, out value9);
				Int(o2, "omittedEntries", text, issues, 0L, 100000000L, out value10);
				if (Arr(o2, "items", text, issues, 0, 256, out var a2))
				{
					num += ((JContainer)a2).Count;
					HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
					for (int j = 0; j < ((JContainer)a2).Count; j++)
					{
						string path = text + ".items." + j;
						if (ObjAt(a2[j], path, issues, out var o3))
						{
							Keys(o3, path, issues, "prefab", "quality", "stack");
							string value11;
							bool num2 = Str(o3, "prefab", path, issues, 0, null, Prefab, out value11);
							int value12;
							bool flag9 = Int(o3, "quality", path, issues, 1L, 10L, out value12);
							Int(o3, "stack", path, issues, 1L, 1000000000L, out value10);
							if (num2 && flag9 && !hashSet2.Add(value11 + "@" + value12.ToString(CultureInfo.InvariantCulture)))
							{
								issues.Add(new ValidationIssue(path, "custom", "duplicate (prefab, quality) stack"));
							}
						}
					}
					if (flag8 && value9 && (((JContainer)a2).Count > 0 || (flag7 && value8 != 0)))
					{
						issues.Add(new ValidationIssue(text + ".items", "custom", "an unreadable container carries no items"));
					}
				}
				if (flag6 && flag7 && value8 > value7)
				{
					issues.Add(new ValidationIssue(text + ".usedSlots", "custom", "usedSlots exceeds slots"));
				}
				if (flag && flag2 && flag3 && flag4 && flag5 && !hashSet.Add(value + "|" + Coord(value2) + "|" + Coord(value3) + "|" + Coord(value4) + "|" + value5))
				{
					issues.Add(new ValidationIssue(text, "custom", "duplicate container (prefab, position, creator)"));
				}
			}
			if (num > 50000)
			{
				issues.Add(new ValidationIssue("containers", "too_big", $"items summed over all containers exceed {50000}"));
			}
		}
		Int(o, "omittedShared", "", issues, 0L, 1000000L, out value10);
		Int(o, "omittedPrivate", "", issues, 0L, 1000000L, out value10);
	}

	private static void Recipes(JObject o, List<ValidationIssue> issues)
	{
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Invalid comparison between Unknown and I4
		//IL_0b7e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b85: Invalid comparison between Unknown and I4
		//IL_07f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_07f7: Invalid comparison between Unknown and I4
		Keys(o, "", issues, HeaderKeys, "locale", "atlas", "stations", "recipes", "pieces", "processors", "processes");
		Header(o, issues);
		Str(o, "locale", "", issues, 0, null, Locale);
		bool hasAtlas = false;
		int w = 0;
		int h = 0;
		JToken val = o["atlas"];
		JObject o2;
		if (val == null)
		{
			issues.Add(new ValidationIssue("atlas", "invalid_type", "required (nullable)"));
		}
		else if ((int)val.Type != 10 && ObjAt(val, "atlas", issues, out o2))
		{
			hasAtlas = BinaryRef(o2, "atlas", issues, out w, out h);
		}
		AtlasCheck atlasCheck = new AtlasCheck
		{
			HasAtlas = hasAtlas,
			Width = w,
			Height = h
		};
		int num = 0;
		HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
		int value2;
		if (Arr(o, "stations", "", issues, 0, 256, out var a))
		{
			for (int i = 0; i < ((JContainer)a).Count; i++)
			{
				string text = "stations." + i;
				if (ObjAt(a[i], text, issues, out var o3))
				{
					Keys(o3, text, issues, "prefab", "name", "maxLevel", "stackableExtension", "upgrader", "icon");
					if (Str(o3, "prefab", text, issues, 0, null, Prefab, out var value) && !hashSet.Add(value))
					{
						issues.Add(new ValidationIssue(text + ".prefab", "custom", "duplicate stations prefab"));
					}
					Str(o3, "name", text, issues, 1, 96, null);
					Int(o3, "maxLevel", text, issues, 1L, 20L, out value2);
					Bool(o3, "stackableExtension", text, issues);
					OptionalBool(o3, "upgrader", text, issues);
					AtlasIcon(o3, text, issues, atlasCheck);
				}
			}
		}
		string value4;
		if (Arr(o, "recipes", "", issues, 0, 4096, out var a2))
		{
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			for (int j = 0; j < ((JContainer)a2).Count; j++)
			{
				string text2 = "recipes." + j;
				if (ObjAt(a2[j], text2, issues, out var o4))
				{
					Keys(o4, text2, issues, "id", "result", "amount", "enabled", "station", "repairStation", "minStationLevel", "upgradeOnly", "anyOneOf", "qualityResultAmountMultiplier", "formula", "resources");
					if (Str(o4, "id", text2, issues, 0, null, Prefab, out var value3) && !hashSet2.Add(value3))
					{
						issues.Add(new ValidationIssue(text2 + ".id", "custom", "duplicate recipe id"));
					}
					Str(o4, "result", text2, issues, 0, null, Prefab);
					Int(o4, "amount", text2, issues, 1L, 10000L, out value2);
					Bool(o4, "enabled", text2, issues);
					StationRef(o4, "station", text2, issues, hashSet);
					StationRef(o4, "repairStation", text2, issues, hashSet);
					Int(o4, "minStationLevel", text2, issues, 0L, 20L, out value2);
					Bool(o4, "upgradeOnly", text2, issues);
					Bool(o4, "anyOneOf", text2, issues);
					Num(o4, "qualityResultAmountMultiplier", text2, issues, 0.0, 100.0);
					Enum(o4, "formula", text2, issues, Formulas, out value4);
					num += Resources(o4, text2, issues, recipe: true);
				}
			}
		}
		if (Arr(o, "pieces", "", issues, 0, 4096, out var a3))
		{
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			for (int k = 0; k < ((JContainer)a3).Count; k++)
			{
				string text3 = "pieces." + k;
				if (ObjAt(a3[k], text3, issues, out var o5))
				{
					Keys(o5, text3, issues, "prefab", "name", "category", "tool", "station", "icon", "resources");
					if (Str(o5, "prefab", text3, issues, 0, null, Prefab, out var value5) && !hashSet3.Add(value5))
					{
						issues.Add(new ValidationIssue(text3 + ".prefab", "custom", "duplicate pieces prefab"));
					}
					Str(o5, "name", text3, issues, 1, 96, null);
					Str(o5, "category", text3, issues, 0, null, Category);
					Str(o5, "tool", text3, issues, 0, null, Prefab);
					StationRef(o5, "station", text3, issues, hashSet);
					AtlasIcon(o5, text3, issues, atlasCheck);
					num += Resources(o5, text3, issues, recipe: false);
				}
			}
		}
		HashSet<string> hashSet4 = new HashSet<string>(StringComparer.Ordinal);
		if (Arr(o, "processors", "", issues, 0, 256, out var a4))
		{
			for (int l = 0; l < ((JContainer)a4).Count; l++)
			{
				string text4 = "processors." + l;
				if (ObjAt(a4[l], text4, issues, out var o6))
				{
					Keys(o6, text4, issues, "prefab", "type", "fuel", "fuelPerProduct", "fuelSecondsPerUnit", "windPowered", "requiresRoof", "maxInput", "burntResult", "defaultResult");
					if (Str(o6, "prefab", text4, issues, 0, null, Prefab, out var value6) && !hashSet4.Add(value6))
					{
						issues.Add(new ValidationIssue(text4 + ".prefab", "custom", "duplicate processors prefab"));
					}
					Enum(o6, "type", text4, issues, ProcessorTypes, out value4);
					NullablePrefab(o6, "fuel", text4, issues, out value4);
					NullableInt(o6, "fuelPerProduct", text4, issues, 0L, 1000L);
					NullableNum(o6, "fuelSecondsPerUnit", text4, issues, 0.001, 86400.0);
					Bool(o6, "windPowered", text4, issues);
					Bool(o6, "requiresRoof", text4, issues);
					NullableInt(o6, "maxInput", text4, issues, 1L, 10000L);
					NullablePrefab(o6, "burntResult", text4, issues, out value4);
					JToken val2 = o6["defaultResult"];
					JObject o7;
					if (val2 == null)
					{
						issues.Add(new ValidationIssue(text4 + ".defaultResult", "invalid_type", "required (nullable)"));
					}
					else if ((int)val2.Type != 10 && ObjAt(val2, text4 + ".defaultResult", issues, out o7))
					{
						Keys(o7, text4 + ".defaultResult", issues, "prefab", "perInputs");
						Str(o7, "prefab", text4 + ".defaultResult", issues, 0, null, Prefab);
						Int(o7, "perInputs", text4 + ".defaultResult", issues, 1L, 10000L, out value2);
					}
				}
			}
		}
		if (Arr(o, "processes", "", issues, 0, 2048, out var a5))
		{
			for (int m = 0; m < ((JContainer)a5).Count; m++)
			{
				string text5 = "processes." + m;
				if (!ObjAt(a5[m], text5, issues, out var o8))
				{
					continue;
				}
				Keys(o8, text5, issues, "processor", "inputs", "anyOneOf", "output", "seconds", "priority");
				if (Str(o8, "processor", text5, issues, 0, null, Prefab, out var value7) && !hashSet4.Contains(value7))
				{
					issues.Add(new ValidationIssue(text5 + ".processor", "custom", "unknown processor"));
				}
				if (Arr(o8, "inputs", text5, issues, 1, 8, out var a6))
				{
					num += ((JContainer)a6).Count;
					HashSet<string> hashSet5 = new HashSet<string>(StringComparer.Ordinal);
					for (int n = 0; n < ((JContainer)a6).Count; n++)
					{
						string text6 = text5 + ".inputs." + n;
						if (ObjAt(a6[n], text6, issues, out var o9))
						{
							Keys(o9, text6, issues, "prefab", "amount");
							if (Str(o9, "prefab", text6, issues, 0, null, Prefab, out var value8) && !hashSet5.Add(value8))
							{
								issues.Add(new ValidationIssue(text6 + ".prefab", "custom", "duplicate input prefab"));
							}
							Int(o9, "amount", text6, issues, 1L, 10000L, out value2);
						}
					}
				}
				Bool(o8, "anyOneOf", text5, issues);
				if (Obj(o8, "output", text5, issues, out var o10))
				{
					Keys(o10, text5 + ".output", issues, "prefab", "amount");
					Str(o10, "prefab", text5 + ".output", issues, 0, null, Prefab);
					Int(o10, "amount", text5 + ".output", issues, 1L, 10000L, out value2);
				}
				NullableNum(o8, "seconds", text5, issues, 0.0, 604800.0);
				Int(o8, "priority", text5, issues, -10000L, 10000L, out value2);
			}
		}
		if (atlasCheck.Any && val != null && (int)val.Type == 10)
		{
			issues.Add(new ValidationIssue("atlas", "custom", "atlas icon without an atlas"));
		}
		if (num > 12000)
		{
			issues.Add(new ValidationIssue("", "too_big", $"recipe resources, piece resources and process inputs exceed {12000} in total"));
		}
	}

	private static void AtlasIcon(JObject parent, string path, List<ValidationIssue> issues, AtlasCheck atlas)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Invalid comparison between Unknown and I4
		string path2 = Join(path, "icon");
		JToken val = parent["icon"];
		JObject o;
		if (val == null)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "required (nullable)"));
		}
		else if ((int)val.Type != 10 && ObjAt(val, path2, issues, out o))
		{
			atlas.Any = true;
			Keys(o, path2, issues, "kind", "x", "y", "w", "h");
			Literal(o, "kind", path2, issues, "atlas");
			int value;
			bool flag = Int(o, "x", path2, issues, 0L, 16383L, out value);
			int value2;
			bool flag2 = Int(o, "y", path2, issues, 0L, 16383L, out value2);
			int value3;
			bool flag3 = Int(o, "w", path2, issues, 1L, 512L, out value3);
			int value4;
			bool flag4 = Int(o, "h", path2, issues, 1L, 512L, out value4);
			if (atlas.HasAtlas && flag && flag2 && flag3 && flag4 && (value + value3 > atlas.Width || value2 + value4 > atlas.Height))
			{
				issues.Add(new ValidationIssue(path2, "custom", "icon outside atlas"));
			}
		}
	}

	private static int Resources(JObject parent, string path, List<ValidationIssue> issues, bool recipe)
	{
		if (!Arr(parent, "resources", path, issues, 0, 16, out var a))
		{
			return 0;
		}
		HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
		for (int i = 0; i < ((JContainer)a).Count; i++)
		{
			string text = path + ".resources." + i;
			if (ObjAt(a[i], text, issues, out var o))
			{
				if (recipe)
				{
					Keys(o, text, issues, "prefab", "amount", "amountPerLevel", "extraAmountOnlyOneIngredient", "recover", "upgraderResource");
				}
				else
				{
					Keys(o, text, issues, "prefab", "amount", "recover");
				}
				if (Str(o, "prefab", text, issues, 0, null, Prefab, out var value) && !hashSet.Add(value))
				{
					issues.Add(new ValidationIssue(text + ".prefab", "custom", "duplicate resources prefab"));
				}
				Int(o, "amount", text, issues, 0L, 10000L, out var value2);
				if (recipe)
				{
					Int(o, "amountPerLevel", text, issues, 0L, 10000L, out value2);
					Int(o, "extraAmountOnlyOneIngredient", text, issues, 0L, 10000L, out value2);
				}
				Bool(o, "recover", text, issues);
				if (recipe)
				{
					OptionalBool(o, "upgraderResource", text, issues);
				}
			}
		}
		return ((JContainer)a).Count;
	}

	private static void StationRef(JObject parent, string key, string path, List<ValidationIssue> issues, HashSet<string> stations)
	{
		if (NullablePrefab(parent, key, path, issues, out var value) && value != null && !stations.Contains(value))
		{
			issues.Add(new ValidationIssue(Join(path, key), "custom", "unknown station"));
		}
	}

	private static string Coord(double v)
	{
		return ((v == 0.0) ? 0.0 : v).ToString("R", CultureInfo.InvariantCulture);
	}

	private static string Join(string path, string key)
	{
		if (path.Length != 0)
		{
			return path + "." + key;
		}
		return key;
	}

	private static void Keys(JObject o, string path, List<ValidationIssue> issues, string[] first, params string[] rest)
	{
		string[] array = new string[first.Length + rest.Length];
		first.CopyTo(array, 0);
		rest.CopyTo(array, first.Length);
		Keys(o, path, issues, array);
	}

	private static void Keys(JObject o, string path, List<ValidationIssue> issues, params string[] allowed)
	{
		HashSet<string> hashSet = new HashSet<string>(allowed, StringComparer.Ordinal);
		List<string> list = null;
		foreach (JProperty item in o.Properties())
		{
			if (!hashSet.Contains(item.Name))
			{
				(list ?? (list = new List<string>())).Add(item.Name);
			}
		}
		if (list != null)
		{
			issues.Add(new ValidationIssue(path, "unrecognized_keys", "unknown key(s): " + string.Join(", ", list)));
		}
	}

	private static bool ObjAt(JToken t, string path, List<ValidationIssue> issues, out JObject o)
	{
		o = (JObject)(object)((t is JObject) ? t : null);
		if (o != null)
		{
			return true;
		}
		issues.Add(new ValidationIssue(path, "invalid_type", "expected object"));
		return false;
	}

	private static bool Obj(JObject parent, string key, string path, List<ValidationIssue> issues, out JObject o)
	{
		o = null;
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(Join(path, key), "invalid_type", "required"));
			return false;
		}
		return ObjAt(val, Join(path, key), issues, out o);
	}

	private static bool Arr(JObject parent, string key, string path, List<ValidationIssue> issues, int min, int max, out JArray a)
	{
		a = null;
		string path2 = Join(path, key);
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "required"));
			return false;
		}
		a = (JArray)(object)((val is JArray) ? val : null);
		if (a == null)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "expected array"));
			return false;
		}
		if (((JContainer)a).Count < min)
		{
			issues.Add(new ValidationIssue(path2, "too_small", $"at least {min} entries"));
		}
		if (((JContainer)a).Count > max)
		{
			issues.Add(new ValidationIssue(path2, "too_big", $"at most {max} entries"));
		}
		return true;
	}

	private static bool Str(JObject parent, string key, string path, List<ValidationIssue> issues, int min, int? max, Regex pattern)
	{
		string value;
		return Str(parent, key, path, issues, min, max, pattern, out value);
	}

	private static bool Str(JObject parent, string key, string path, List<ValidationIssue> issues, int min, int? max, Regex pattern, out string value)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		value = null;
		string path2 = Join(path, key);
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "required"));
			return false;
		}
		if ((int)val.Type != 8)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "expected string"));
			return false;
		}
		value = (string)val;
		bool flag = true;
		if (value.Length < min)
		{
			issues.Add(new ValidationIssue(path2, "too_small", $"at least {min} chars"));
			flag = false;
		}
		if (max.HasValue && value.Length > max.Value)
		{
			issues.Add(new ValidationIssue(path2, "too_big", $"at most {max} chars"));
			flag = false;
		}
		if (flag && pattern != null && !pattern.IsMatch(value))
		{
			issues.Add(new ValidationIssue(path2, "invalid_format", "pattern " + pattern));
			flag = false;
		}
		return flag;
	}

	private static bool Enum(JObject parent, string key, string path, List<ValidationIssue> issues, string[] values, out string value)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Invalid comparison between Unknown and I4
		JToken val = parent[key];
		value = ((val != null && (int)val.Type == 8) ? ((string)val) : null);
		if (value != null && Array.IndexOf(values, value) >= 0)
		{
			return true;
		}
		issues.Add(new ValidationIssue(Join(path, key), "invalid_value", "one of " + string.Join("|", values)));
		return false;
	}

	private static bool Literal(JObject parent, string key, string path, List<ValidationIssue> issues, string expected)
	{
		string value;
		return Enum(parent, key, path, issues, new string[1] { expected }, out value);
	}

	private static bool Bool(JObject parent, string key, string path, List<ValidationIssue> issues)
	{
		bool value;
		return Bool(parent, key, path, issues, out value);
	}

	private static bool Bool(JObject parent, string key, string path, List<ValidationIssue> issues, out bool value)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		value = false;
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(Join(path, key), "invalid_type", "required"));
			return false;
		}
		if ((int)val.Type != 9)
		{
			issues.Add(new ValidationIssue(Join(path, key), "invalid_type", "expected boolean"));
			return false;
		}
		value = (bool)val;
		return true;
	}

	private static void OptionalBool(JObject parent, string key, string path, List<ValidationIssue> issues)
	{
		if (parent[key] != null)
		{
			Bool(parent, key, path, issues);
		}
	}

	private static bool NullablePrefab(JObject parent, string key, string path, List<ValidationIssue> issues, out string value)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		value = null;
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(Join(path, key), "invalid_type", "required (nullable)"));
			return false;
		}
		if ((int)val.Type == 10)
		{
			return true;
		}
		return Str(parent, key, path, issues, 0, null, Prefab, out value);
	}

	private static void NullableInt(JObject parent, string key, string path, List<ValidationIssue> issues, long min, long max)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Invalid comparison between Unknown and I4
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(Join(path, key), "invalid_type", "required (nullable)"));
		}
		else if ((int)val.Type != 10)
		{
			Int(parent, key, path, issues, min, max, out var _);
		}
	}

	private static bool NumberToken(JToken t, out double v)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Invalid comparison between Unknown and I4
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Invalid comparison between Unknown and I4
		v = 0.0;
		if (t == null)
		{
			return false;
		}
		if ((int)t.Type == 6)
		{
			v = (long)t;
			return true;
		}
		if ((int)t.Type == 7)
		{
			v = (double)t;
			if (!double.IsNaN(v))
			{
				return !double.IsInfinity(v);
			}
			return false;
		}
		return false;
	}

	private static bool Int(JObject parent, string key, string path, List<ValidationIssue> issues, long min, long max, out int value)
	{
		value = 0;
		string path2 = Join(path, key);
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "required"));
			return false;
		}
		if (!NumberToken(val, out var v))
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "expected number"));
			return false;
		}
		if (Math.Floor(v) != v)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "expected integer"));
			return false;
		}
		if (v < (double)min)
		{
			issues.Add(new ValidationIssue(path2, "too_small", $">= {min}"));
			return false;
		}
		if (v > (double)max)
		{
			issues.Add(new ValidationIssue(path2, "too_big", $"<= {max}"));
			return false;
		}
		value = (int)v;
		return true;
	}

	private static bool Num(JObject parent, string key, string path, List<ValidationIssue> issues, double min, double max)
	{
		double value;
		return Num(parent, key, path, issues, min, max, out value);
	}

	private static bool Num(JObject parent, string key, string path, List<ValidationIssue> issues, double min, double max, out double value)
	{
		value = 0.0;
		string path2 = Join(path, key);
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "required"));
			return false;
		}
		if (!NumberToken(val, out var v))
		{
			issues.Add(new ValidationIssue(path2, "invalid_type", "expected number"));
			return false;
		}
		if (v < min)
		{
			issues.Add(new ValidationIssue(path2, "too_small", $">= {min}"));
			return false;
		}
		if (v > max)
		{
			issues.Add(new ValidationIssue(path2, "too_big", $"<= {max}"));
			return false;
		}
		value = v;
		return true;
	}

	private static bool NullableNum(JObject parent, string key, string path, List<ValidationIssue> issues, double min, double max)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		JToken val = parent[key];
		if (val == null)
		{
			issues.Add(new ValidationIssue(Join(path, key), "invalid_type", "required (nullable)"));
			return false;
		}
		if ((int)val.Type == 10)
		{
			return true;
		}
		Num(parent, key, path, issues, min, max);
		return false;
	}

	private static void SteamId64(JObject parent, string key, string path, List<ValidationIssue> issues)
	{
		if (Str(parent, key, path, issues, 1, null, SteamId, out var value) && BigInteger.Parse(value, CultureInfo.InvariantCulture) < SteamMin)
		{
			issues.Add(new ValidationIssue(Join(path, key), "custom", "SteamID64 must be >= 76561197960265728"));
		}
	}

	private static void Int64Str(JObject parent, string key, string path, List<ValidationIssue> issues)
	{
		Int64Str(parent, key, path, issues, out var _);
	}

	private static bool Int64Str(JObject parent, string key, string path, List<ValidationIssue> issues, out string value)
	{
		if (!Str(parent, key, path, issues, 1, null, Int64, out value))
		{
			return false;
		}
		BigInteger bigInteger = BigInteger.Parse(value, CultureInfo.InvariantCulture);
		if (bigInteger >= I64Min && bigInteger <= I64Max)
		{
			return true;
		}
		issues.Add(new ValidationIssue(Join(path, key), "custom", "outside the signed 64-bit range"));
		return false;
	}

	private static void PrefabList(JObject parent, string key, string path, List<ValidationIssue> issues, int max)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		if (!Arr(parent, key, path, issues, 0, max, out var a))
		{
			return;
		}
		for (int i = 0; i < ((JContainer)a).Count; i++)
		{
			string path2 = Join(path, key) + "." + i;
			if ((int)a[i].Type != 8)
			{
				issues.Add(new ValidationIssue(path2, "invalid_type", "expected string"));
			}
			else if (!Prefab.IsMatch((string)a[i]))
			{
				issues.Add(new ValidationIssue(path2, "invalid_format", "prefab id"));
			}
		}
	}
}