Lordfirespeed-OdinSerializer Source

Communities

Lethal CompanyOdinSerializer

Install

Last Updated

First Uploaded

Downloads

5.3M

Likes

Size

569KB

Dependency string

Lordfirespeed-OdinSerializer-2024.2.2700

Dependants

3835 other mods

Tools Libraries Misc

Download

Details Required (0)Wiki ~~Changelog~~Versions Analysis

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration.Assemblies;
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.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using JetBrains.Annotations;
using OdinSerializer;
using OdinSerializer.Utilities;
using OdinSerializer.Utilities.Unsafe;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RegisterFormatterLocator(typeof(ArrayFormatterLocator), -80)]
[assembly: RegisterFormatterLocator(typeof(DelegateFormatterLocator), -50)]
[assembly: RegisterFormatterLocator(typeof(GenericCollectionFormatterLocator), -100)]
[assembly: RegisterFormatterLocator(typeof(ISerializableFormatterLocator), -110)]
[assembly: RegisterFormatterLocator(typeof(SelfFormatterLocator), -60)]
[assembly: RegisterFormatterLocator(typeof(TypeFormatterLocator), -70)]
[assembly: RegisterFormatter(typeof(ArrayListFormatter), 0)]
[assembly: RegisterFormatter(typeof(DateTimeFormatter), 0)]
[assembly: RegisterFormatter(typeof(DateTimeOffsetFormatter), 0)]
[assembly: RegisterFormatter(typeof(DerivedDictionaryFormatter<, , >), typeof(WeakDictionaryFormatter), -1)]
[assembly: RegisterFormatter(typeof(DictionaryFormatter<, >), typeof(WeakDictionaryFormatter), 0)]
[assembly: RegisterFormatter(typeof(DoubleLookupDictionaryFormatter<, , >), typeof(WeakDoubleLookupDictionaryFormatter), 0)]
[assembly: RegisterFormatter(typeof(HashSetFormatter<>), typeof(WeakHashSetFormatter), 0)]
[assembly: RegisterFormatter(typeof(KeyValuePairFormatter<, >), typeof(WeakKeyValuePairFormatter), 0)]
[assembly: RegisterFormatter(typeof(ListFormatter<>), typeof(WeakListFormatter), 0)]
[assembly: RegisterFormatter(typeof(MethodInfoFormatter<>), typeof(WeakMethodInfoFormatter), 0)]
[assembly: RegisterFormatter(typeof(NullableFormatter<>), typeof(WeakNullableFormatter), 0)]
[assembly: RegisterFormatter(typeof(QueueFormatter<, >), typeof(WeakQueueFormatter), 0)]
[assembly: RegisterFormatter(typeof(StackFormatter<, >), typeof(WeakStackFormatter), 0)]
[assembly: RegisterFormatter(typeof(TimeSpanFormatter), 0)]
[assembly: RegisterFormatter(typeof(VersionFormatter), 0)]
[assembly: RegisterDictionaryKeyPathProvider(typeof(Vector2DictionaryKeyPathProvider))]
[assembly: RegisterDictionaryKeyPathProvider(typeof(Vector3DictionaryKeyPathProvider))]
[assembly: RegisterDictionaryKeyPathProvider(typeof(Vector4DictionaryKeyPathProvider))]
[assembly: RegisterFormatter(typeof(AnimationCurveFormatter), 0)]
[assembly: RegisterFormatter(typeof(BoundsFormatter), 0)]
[assembly: RegisterFormatter(typeof(Color32Formatter), 0)]
[assembly: RegisterFormatterLocator(typeof(ColorBlockFormatterLocator), 0)]
[assembly: RegisterFormatter(typeof(ColorFormatter), 0)]
[assembly: RegisterFormatter(typeof(CoroutineFormatter), 0)]
[assembly: RegisterFormatter(typeof(GradientAlphaKeyFormatter), 0)]
[assembly: RegisterFormatter(typeof(GradientColorKeyFormatter), 0)]
[assembly: RegisterFormatter(typeof(GradientFormatter), 0)]
[assembly: RegisterFormatter(typeof(KeyframeFormatter), 0)]
[assembly: RegisterFormatter(typeof(LayerMaskFormatter), 0)]
[assembly: RegisterFormatter(typeof(QuaternionFormatter), 0)]
[assembly: RegisterFormatter(typeof(RectFormatter), 0)]
[assembly: RegisterFormatter(typeof(UnityEventFormatter<>), typeof(WeakUnityEventFormatter), 0)]
[assembly: RegisterFormatter(typeof(Vector2Formatter), 0)]
[assembly: RegisterFormatter(typeof(Vector3Formatter), 0)]
[assembly: RegisterFormatter(typeof(Vector4Formatter), 0)]
[assembly: RegisterFormatter(typeof(Vector2IntFormatter), 0)]
[assembly: RegisterFormatter(typeof(Vector3IntFormatter), 0)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Sirenix IVS")]
[assembly: AssemblyConfiguration("Release JIT")]
[assembly: AssemblyCopyright("Copyright © 2018")]
[assembly: AssemblyFileVersion("2024.2.2700.0")]
[assembly: AssemblyInformationalVersion("2024.2.2700+17459f242d0a3ae7ad79384bb87781923c813f23")]
[assembly: AssemblyProduct("OdinSerializer")]
[assembly: AssemblyTitle("OdinSerializer")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Lordfirespeed/OdinSerializerThunderstore")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace OdinSerializer
{
	public class GlobalSerializationConfig
	{
		private static readonly GlobalSerializationConfig instance = new GlobalSerializationConfig();

		public static GlobalSerializationConfig Instance => instance;

		public ILogger Logger => DefaultLoggers.UnityLogger;

		public DataFormat EditorSerializationFormat => DataFormat.Nodes;

		public DataFormat BuildSerializationFormat => DataFormat.Binary;

		public LoggingPolicy LoggingPolicy => LoggingPolicy.LogErrors;

		public ErrorHandlingPolicy ErrorHandlingPolicy => ErrorHandlingPolicy.Resilient;

		internal static bool HasInstanceLoaded => true;

		internal static void LoadInstanceIfAssetExists()
		{
		}
	}
	public abstract class BaseDataReader : BaseDataReaderWriter, IDataReader, IDisposable
	{
		private DeserializationContext context;

		private Stream stream;

		public int CurrentNodeId => base.CurrentNode.Id;

		public int CurrentNodeDepth => base.NodeDepth;

		public string CurrentNodeName => base.CurrentNode.Name;

		public virtual Stream Stream
		{
			get
			{
				return stream;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (!value.CanRead)
				{
					throw new ArgumentException("Cannot read from stream");
				}
				stream = value;
			}
		}

		public DeserializationContext Context
		{
			get
			{
				if (context == null)
				{
					context = new DeserializationContext();
				}
				return context;
			}
			set
			{
				context = value;
			}
		}

		protected BaseDataReader(Stream stream, DeserializationContext context)
		{
			this.context = context;
			if (stream != null)
			{
				Stream = stream;
			}
		}

		public abstract bool EnterNode(out Type type);

		public abstract bool ExitNode();

		public abstract bool EnterArray(out long length);

		public abstract bool ExitArray();

		public abstract bool ReadPrimitiveArray<T>(out T[] array) where T : struct;

		public abstract EntryType PeekEntry(out string name);

		public abstract bool ReadInternalReference(out int id);

		public abstract bool ReadExternalReference(out int index);

		public abstract bool ReadExternalReference(out Guid guid);

		public abstract bool ReadExternalReference(out string id);

		public abstract bool ReadChar(out char value);

		public abstract bool ReadString(out string value);

		public abstract bool ReadGuid(out Guid value);

		public abstract bool ReadSByte(out sbyte value);

		public abstract bool ReadInt16(out short value);

		public abstract bool ReadInt32(out int value);

		public abstract bool ReadInt64(out long value);

		public abstract bool ReadByte(out byte value);

		public abstract bool ReadUInt16(out ushort value);

		public abstract bool ReadUInt32(out uint value);

		public abstract bool ReadUInt64(out ulong value);

		public abstract bool ReadDecimal(out decimal value);

		public abstract bool ReadSingle(out float value);

		public abstract bool ReadDouble(out double value);

		public abstract bool ReadBoolean(out bool value);

		public abstract bool ReadNull();

		public virtual void SkipEntry()
		{
			switch (PeekEntry())
			{
			case EntryType.StartOfNode:
			{
				bool flag = true;
				EnterNode(out var type);
				try
				{
					if (type != null)
					{
						if (FormatterUtilities.IsPrimitiveType(type))
						{
							Serializer serializer = Serializer.Get(type);
							object reference = serializer.ReadValueWeak(this);
							if (CurrentNodeId >= 0)
							{
								Context.RegisterInternalReference(CurrentNodeId, reference);
							}
						}
						else
						{
							IFormatter formatter = FormatterLocator.GetFormatter(type, Context.Config.SerializationPolicy);
							object reference2 = formatter.Deserialize(this);
							if (CurrentNodeId >= 0)
							{
								Context.RegisterInternalReference(CurrentNodeId, reference2);
							}
						}
						break;
					}
					while (true)
					{
						switch (PeekEntry())
						{
						case EntryType.EndOfArray:
							ReadToNextEntry();
							break;
						default:
							SkipEntry();
							break;
						case EntryType.EndOfNode:
						case EntryType.EndOfStream:
							return;
						}
					}
				}
				catch (SerializationAbortException ex)
				{
					flag = false;
					throw ex;
				}
				finally
				{
					if (flag)
					{
						ExitNode();
					}
				}
			}
			case EntryType.StartOfArray:
				ReadToNextEntry();
				while (true)
				{
					switch (PeekEntry())
					{
					case EntryType.EndOfArray:
						ReadToNextEntry();
						return;
					case EntryType.EndOfNode:
						ReadToNextEntry();
						break;
					default:
						SkipEntry();
						break;
					case EntryType.EndOfStream:
						return;
					}
				}
			default:
				ReadToNextEntry();
				break;
			case EntryType.EndOfNode:
			case EntryType.EndOfArray:
				break;
			}
		}

		public abstract void Dispose();

		public virtual void PrepareNewSerializationSession()
		{
			ClearNodes();
		}

		public abstract string GetDataDump();

		protected abstract EntryType PeekEntry();

		protected abstract EntryType ReadToNextEntry();
	}
	public abstract class BaseDataReaderWriter
	{
		private NodeInfo[] nodes = new NodeInfo[32];

		private int nodesLength;

		[Obsolete("Use the Binder member on the writer's SerializationContext/DeserializationContext instead.", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public TwoWaySerializationBinder Binder
		{
			get
			{
				if (this is IDataWriter)
				{
					return (this as IDataWriter).Context.Binder;
				}
				if (this is IDataReader)
				{
					return (this as IDataReader).Context.Binder;
				}
				return TwoWaySerializationBinder.Default;
			}
			set
			{
				if (this is IDataWriter)
				{
					(this as IDataWriter).Context.Binder = value;
				}
				else if (this is IDataReader)
				{
					(this as IDataReader).Context.Binder = value;
				}
			}
		}

		public bool IsInArrayNode
		{
			get
			{
				if (nodesLength != 0)
				{
					return nodes[nodesLength - 1].IsArray;
				}
				return false;
			}
		}

		protected int NodeDepth => nodesLength;

		protected NodeInfo[] NodesArray => nodes;

		protected NodeInfo CurrentNode
		{
			get
			{
				if (nodesLength != 0)
				{
					return nodes[nodesLength - 1];
				}
				return NodeInfo.Empty;
			}
		}

		protected void PushNode(NodeInfo node)
		{
			if (nodesLength == nodes.Length)
			{
				ExpandNodes();
			}
			nodes[nodesLength] = node;
			nodesLength++;
		}

		protected void PushNode(string name, int id, Type type)
		{
			if (nodesLength == nodes.Length)
			{
				ExpandNodes();
			}
			nodes[nodesLength] = new NodeInfo(name, id, type, isArray: false);
			nodesLength++;
		}

		protected void PushArray()
		{
			if (nodesLength == nodes.Length)
			{
				ExpandNodes();
			}
			if (nodesLength == 0 || nodes[nodesLength - 1].IsArray)
			{
				nodes[nodesLength] = new NodeInfo(null, -1, null, isArray: true);
			}
			else
			{
				NodeInfo nodeInfo = nodes[nodesLength - 1];
				nodes[nodesLength] = new NodeInfo(nodeInfo.Name, nodeInfo.Id, nodeInfo.Type, isArray: true);
			}
			nodesLength++;
		}

		private void ExpandNodes()
		{
			NodeInfo[] array = new NodeInfo[nodes.Length * 2];
			NodeInfo[] array2 = nodes;
			for (int i = 0; i < array2.Length; i++)
			{
				array[i] = array2[i];
			}
			nodes = array;
		}

		protected void PopNode(string name)
		{
			if (nodesLength == 0)
			{
				throw new InvalidOperationException("There are no nodes to pop.");
			}
			nodesLength--;
		}

		protected void PopArray()
		{
			if (nodesLength == 0)
			{
				throw new InvalidOperationException("There are no nodes to pop.");
			}
			if (!nodes[nodesLength - 1].IsArray)
			{
				throw new InvalidOperationException("Was not in array when exiting array.");
			}
			nodesLength--;
		}

		protected void ClearNodes()
		{
			nodesLength = 0;
		}
	}
	public abstract class BaseDataWriter : BaseDataReaderWriter, IDataWriter, IDisposable
	{
		private SerializationContext context;

		private Stream stream;

		public virtual Stream Stream
		{
			get
			{
				return stream;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (!value.CanWrite)
				{
					throw new ArgumentException("Cannot write to stream");
				}
				stream = value;
			}
		}

		public SerializationContext Context
		{
			get
			{
				if (context == null)
				{
					context = new SerializationContext();
				}
				return context;
			}
			set
			{
				context = value;
			}
		}

		protected BaseDataWriter(Stream stream, SerializationContext context)
		{
			this.context = context;
			if (stream != null)
			{
				Stream = stream;
			}
		}

		public virtual void FlushToStream()
		{
			Stream.Flush();
		}

		public abstract void BeginReferenceNode(string name, Type type, int id);

		public abstract void BeginStructNode(string name, Type type);

		public abstract void EndNode(string name);

		public abstract void BeginArrayNode(long length);

		public abstract void EndArrayNode();

		public abstract void WritePrimitiveArray<T>(T[] array) where T : struct;

		public abstract void WriteNull(string name);

		public abstract void WriteInternalReference(string name, int id);

		public abstract void WriteExternalReference(string name, int index);

		public abstract void WriteExternalReference(string name, Guid guid);

		public abstract void WriteExternalReference(string name, string id);

		public abstract void WriteChar(string name, char value);

		public abstract void WriteString(string name, string value);

		public abstract void WriteGuid(string name, Guid value);

		public abstract void WriteSByte(string name, sbyte value);

		public abstract void WriteInt16(string name, short value);

		public abstract void WriteInt32(string name, int value);

		public abstract void WriteInt64(string name, long value);

		public abstract void WriteByte(string name, byte value);

		public abstract void WriteUInt16(string name, ushort value);

		public abstract void WriteUInt32(string name, uint value);

		public abstract void WriteUInt64(string name, ulong value);

		public abstract void WriteDecimal(string name, decimal value);

		public abstract void WriteSingle(string name, float value);

		public abstract void WriteDouble(string name, double value);

		public abstract void WriteBoolean(string name, bool value);

		public abstract void Dispose();

		public virtual void PrepareNewSerializationSession()
		{
			ClearNodes();
		}

		public abstract string GetDataDump();
	}
	public class BinaryDataReader : BaseDataReader
	{
		private struct Struct256Bit
		{
			public decimal d1;

			public decimal d2;
		}

		private static readonly Dictionary<Type, Delegate> PrimitiveFromByteMethods = new Dictionary<Type, Delegate>
		{
			{
				typeof(char),
				(Func<byte[], int, char>)((byte[] b, int i) => (char)ProperBitConverter.ToUInt16(b, i))
			},
			{
				typeof(byte),
				(Func<byte[], int, byte>)((byte[] b, int i) => b[i])
			},
			{
				typeof(sbyte),
				(Func<byte[], int, sbyte>)((byte[] b, int i) => (sbyte)b[i])
			},
			{
				typeof(bool),
				(Func<byte[], int, bool>)((byte[] b, int i) => b[i] != 0)
			},
			{
				typeof(short),
				new Func<byte[], int, short>(ProperBitConverter.ToInt16)
			},
			{
				typeof(int),
				new Func<byte[], int, int>(ProperBitConverter.ToInt32)
			},
			{
				typeof(long),
				new Func<byte[], int, long>(ProperBitConverter.ToInt64)
			},
			{
				typeof(ushort),
				new Func<byte[], int, ushort>(ProperBitConverter.ToUInt16)
			},
			{
				typeof(uint),
				new Func<byte[], int, uint>(ProperBitConverter.ToUInt32)
			},
			{
				typeof(ulong),
				new Func<byte[], int, ulong>(ProperBitConverter.ToUInt64)
			},
			{
				typeof(decimal),
				new Func<byte[], int, decimal>(ProperBitConverter.ToDecimal)
			},
			{
				typeof(float),
				new Func<byte[], int, float>(ProperBitConverter.ToSingle)
			},
			{
				typeof(double),
				new Func<byte[], int, double>(ProperBitConverter.ToDouble)
			},
			{
				typeof(Guid),
				new Func<byte[], int, Guid>(ProperBitConverter.ToGuid)
			}
		};

		private byte[] internalBufferBackup;

		private byte[] buffer = new byte[102400];

		private int bufferIndex;

		private int bufferEnd;

		private EntryType? peekedEntryType;

		private BinaryEntryType peekedBinaryEntryType;

		private string peekedEntryName;

		private Dictionary<int, Type> types = new Dictionary<int, Type>(16);

		public BinaryDataReader()
			: base(null, null)
		{
			internalBufferBackup = buffer;
		}

		public BinaryDataReader(Stream stream, DeserializationContext context)
			: base(stream, context)
		{
			internalBufferBackup = buffer;
		}

		public override void Dispose()
		{
		}

		public override EntryType PeekEntry(out string name)
		{
			if (peekedEntryType.HasValue)
			{
				name = peekedEntryName;
				return peekedEntryType.Value;
			}
			peekedBinaryEntryType = (BinaryEntryType)(HasBufferData(1) ? buffer[bufferIndex++] : 49);
			switch (peekedBinaryEntryType)
			{
			case BinaryEntryType.EndOfStream:
				name = null;
				peekedEntryName = null;
				peekedEntryType = EntryType.EndOfStream;
				break;
			case BinaryEntryType.NamedStartOfReferenceNode:
			case BinaryEntryType.NamedStartOfStructNode:
				name = ReadStringValue();
				peekedEntryType = EntryType.StartOfNode;
				break;
			case BinaryEntryType.UnnamedStartOfReferenceNode:
			case BinaryEntryType.UnnamedStartOfStructNode:
				name = null;
				peekedEntryType = EntryType.StartOfNode;
				break;
			case BinaryEntryType.EndOfNode:
				name = null;
				peekedEntryType = EntryType.EndOfNode;
				break;
			case BinaryEntryType.StartOfArray:
				name = null;
				peekedEntryType = EntryType.StartOfArray;
				break;
			case BinaryEntryType.EndOfArray:
				name = null;
				peekedEntryType = EntryType.EndOfArray;
				break;
			case BinaryEntryType.PrimitiveArray:
				name = null;
				peekedEntryType = EntryType.PrimitiveArray;
				break;
			case BinaryEntryType.NamedInternalReference:
				name = ReadStringValue();
				peekedEntryType = EntryType.InternalReference;
				break;
			case BinaryEntryType.UnnamedInternalReference:
				name = null;
				peekedEntryType = EntryType.InternalReference;
				break;
			case BinaryEntryType.NamedExternalReferenceByIndex:
				name = ReadStringValue();
				peekedEntryType = EntryType.ExternalReferenceByIndex;
				break;
			case BinaryEntryType.UnnamedExternalReferenceByIndex:
				name = null;
				peekedEntryType = EntryType.ExternalReferenceByIndex;
				break;
			case BinaryEntryType.NamedExternalReferenceByGuid:
				name = ReadStringValue();
				peekedEntryType = EntryType.ExternalReferenceByGuid;
				break;
			case BinaryEntryType.UnnamedExternalReferenceByGuid:
				name = null;
				peekedEntryType = EntryType.ExternalReferenceByGuid;
				break;
			case BinaryEntryType.NamedExternalReferenceByString:
				name = ReadStringValue();
				peekedEntryType = EntryType.ExternalReferenceByString;
				break;
			case BinaryEntryType.UnnamedExternalReferenceByString:
				name = null;
				peekedEntryType = EntryType.ExternalReferenceByString;
				break;
			case BinaryEntryType.NamedSByte:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedSByte:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedByte:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedByte:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedShort:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedShort:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedUShort:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedUShort:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedInt:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedInt:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedUInt:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedUInt:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedLong:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedLong:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedULong:
				name = ReadStringValue();
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.UnnamedULong:
				name = null;
				peekedEntryType = EntryType.Integer;
				break;
			case BinaryEntryType.NamedFloat:
				name = ReadStringValue();
				peekedEntryType = EntryType.FloatingPoint;
				break;
			case BinaryEntryType.UnnamedFloat:
				name = null;
				peekedEntryType = EntryType.FloatingPoint;
				break;
			case BinaryEntryType.NamedDouble:
				name = ReadStringValue();
				peekedEntryType = EntryType.FloatingPoint;
				break;
			case BinaryEntryType.UnnamedDouble:
				name = null;
				peekedEntryType = EntryType.FloatingPoint;
				break;
			case BinaryEntryType.NamedDecimal:
				name = ReadStringValue();
				peekedEntryType = EntryType.FloatingPoint;
				break;
			case BinaryEntryType.UnnamedDecimal:
				name = null;
				peekedEntryType = EntryType.FloatingPoint;
				break;
			case BinaryEntryType.NamedChar:
				name = ReadStringValue();
				peekedEntryType = EntryType.String;
				break;
			case BinaryEntryType.UnnamedChar:
				name = null;
				peekedEntryType = EntryType.String;
				break;
			case BinaryEntryType.NamedString:
				name = ReadStringValue();
				peekedEntryType = EntryType.String;
				break;
			case BinaryEntryType.UnnamedString:
				name = null;
				peekedEntryType = EntryType.String;
				break;
			case BinaryEntryType.NamedGuid:
				name = ReadStringValue();
				peekedEntryType = EntryType.Guid;
				break;
			case BinaryEntryType.UnnamedGuid:
				name = null;
				peekedEntryType = EntryType.Guid;
				break;
			case BinaryEntryType.NamedBoolean:
				name = ReadStringValue();
				peekedEntryType = EntryType.Boolean;
				break;
			case BinaryEntryType.UnnamedBoolean:
				name = null;
				peekedEntryType = EntryType.Boolean;
				break;
			case BinaryEntryType.NamedNull:
				name = ReadStringValue();
				peekedEntryType = EntryType.Null;
				break;
			case BinaryEntryType.UnnamedNull:
				name = null;
				peekedEntryType = EntryType.Null;
				break;
			case BinaryEntryType.TypeName:
			case BinaryEntryType.TypeID:
				peekedBinaryEntryType = BinaryEntryType.Invalid;
				peekedEntryType = EntryType.Invalid;
				throw new InvalidOperationException("Invalid binary data stream: BinaryEntryType.TypeName and BinaryEntryType.TypeID must never be peeked by the binary reader.");
			default:
			{
				name = null;
				peekedBinaryEntryType = BinaryEntryType.Invalid;
				peekedEntryType = EntryType.Invalid;
				byte b = (byte)peekedBinaryEntryType;
				throw new InvalidOperationException("Invalid binary data stream: could not parse peeked BinaryEntryType byte '" + b + "' into a known entry type.");
			}
			}
			peekedEntryName = name;
			return peekedEntryType.Value;
		}

		public override bool EnterArray(out long length)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedEntryType == EntryType.StartOfArray)
			{
				PushArray();
				MarkEntryContentConsumed();
				if (UNSAFE_Read_8_Int64(out length))
				{
					if (length < 0)
					{
						length = 0L;
						base.Context.Config.DebugContext.LogError("Invalid array length: " + length + ".");
						return false;
					}
					return true;
				}
				return false;
			}
			SkipEntry();
			length = 0L;
			return false;
		}

		public override bool EnterNode(out Type type)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedStartOfReferenceNode || peekedBinaryEntryType == BinaryEntryType.UnnamedStartOfReferenceNode)
			{
				MarkEntryContentConsumed();
				type = ReadTypeEntry();
				if (!UNSAFE_Read_4_Int32(out var value))
				{
					type = null;
					return false;
				}
				PushNode(peekedEntryName, value, type);
				return true;
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedStartOfStructNode || peekedBinaryEntryType == BinaryEntryType.UnnamedStartOfStructNode)
			{
				type = ReadTypeEntry();
				PushNode(peekedEntryName, -1, type);
				MarkEntryContentConsumed();
				return true;
			}
			SkipEntry();
			type = null;
			return false;
		}

		public override bool ExitArray()
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			while (peekedBinaryEntryType != BinaryEntryType.EndOfArray && peekedBinaryEntryType != BinaryEntryType.EndOfStream)
			{
				if (peekedEntryType == EntryType.EndOfNode)
				{
					base.Context.Config.DebugContext.LogError("Data layout mismatch; skipping past node boundary when exiting array.");
					MarkEntryContentConsumed();
				}
				SkipEntry();
			}
			if (peekedBinaryEntryType == BinaryEntryType.EndOfArray)
			{
				MarkEntryContentConsumed();
				PopArray();
				return true;
			}
			return false;
		}

		public override bool ExitNode()
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			while (peekedBinaryEntryType != BinaryEntryType.EndOfNode && peekedBinaryEntryType != BinaryEntryType.EndOfStream)
			{
				if (peekedEntryType == EntryType.EndOfArray)
				{
					base.Context.Config.DebugContext.LogError("Data layout mismatch; skipping past array boundary when exiting node.");
					MarkEntryContentConsumed();
				}
				SkipEntry();
			}
			if (peekedBinaryEntryType == BinaryEntryType.EndOfNode)
			{
				MarkEntryContentConsumed();
				PopNode(base.CurrentNodeName);
				return true;
			}
			return false;
		}

		public unsafe override bool ReadPrimitiveArray<T>(out T[] array)
		{
			if (!FormatterUtilities.IsPrimitiveArrayType(typeof(T)))
			{
				throw new ArgumentException("Type " + typeof(T).Name + " is not a valid primitive array type.");
			}
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedEntryType == EntryType.PrimitiveArray)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_4_Int32(out var value) || !UNSAFE_Read_4_Int32(out var value2))
				{
					array = null;
					return false;
				}
				int num = value * value2;
				if (!HasBufferData(num))
				{
					bufferIndex = bufferEnd;
					array = null;
					return false;
				}
				if (typeof(T) == typeof(byte))
				{
					byte[] array2 = new byte[num];
					Buffer.BlockCopy(buffer, bufferIndex, array2, 0, num);
					array = (T[])(object)array2;
					bufferIndex += num;
					return true;
				}
				array = new T[value];
				if (BitConverter.IsLittleEndian)
				{
					GCHandle gCHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
					try
					{
						fixed (byte* ptr = buffer)
						{
							void* from = ptr + bufferIndex;
							void* to = gCHandle.AddrOfPinnedObject().ToPointer();
							UnsafeUtilities.MemoryCopy(from, to, num);
						}
					}
					finally
					{
						gCHandle.Free();
					}
				}
				else
				{
					Func<byte[], int, T> func = (Func<byte[], int, T>)PrimitiveFromByteMethods[typeof(T)];
					for (int i = 0; i < value; i++)
					{
						array[i] = func(buffer, bufferIndex + i * value2);
					}
				}
				bufferIndex += num;
				return true;
			}
			SkipEntry();
			array = null;
			return false;
		}

		public override bool ReadBoolean(out bool value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedEntryType == EntryType.Boolean)
			{
				MarkEntryContentConsumed();
				if (HasBufferData(1))
				{
					value = buffer[bufferIndex++] == 1;
					return true;
				}
				value = false;
				return false;
			}
			SkipEntry();
			value = false;
			return false;
		}

		public override bool ReadSByte(out sbyte value)
		{
			if (ReadInt64(out var value2))
			{
				try
				{
					value = checked((sbyte)value2);
				}
				catch (OverflowException)
				{
					value = 0;
				}
				return true;
			}
			value = 0;
			return false;
		}

		public override bool ReadByte(out byte value)
		{
			if (ReadUInt64(out var value2))
			{
				try
				{
					value = checked((byte)value2);
				}
				catch (OverflowException)
				{
					value = 0;
				}
				return true;
			}
			value = 0;
			return false;
		}

		public override bool ReadInt16(out short value)
		{
			if (ReadInt64(out var value2))
			{
				try
				{
					value = checked((short)value2);
				}
				catch (OverflowException)
				{
					value = 0;
				}
				return true;
			}
			value = 0;
			return false;
		}

		public override bool ReadUInt16(out ushort value)
		{
			if (ReadUInt64(out var value2))
			{
				try
				{
					value = checked((ushort)value2);
				}
				catch (OverflowException)
				{
					value = 0;
				}
				return true;
			}
			value = 0;
			return false;
		}

		public override bool ReadInt32(out int value)
		{
			if (ReadInt64(out var value2))
			{
				try
				{
					value = checked((int)value2);
				}
				catch (OverflowException)
				{
					value = 0;
				}
				return true;
			}
			value = 0;
			return false;
		}

		public override bool ReadUInt32(out uint value)
		{
			if (ReadUInt64(out var value2))
			{
				try
				{
					value = checked((uint)value2);
				}
				catch (OverflowException)
				{
					value = 0u;
				}
				return true;
			}
			value = 0u;
			return false;
		}

		public override bool ReadInt64(out long value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedEntryType == EntryType.Integer)
			{
				try
				{
					switch (peekedBinaryEntryType)
					{
					case BinaryEntryType.NamedSByte:
					case BinaryEntryType.UnnamedSByte:
					{
						if (!UNSAFE_Read_1_SByte(out var value5))
						{
							value = 0L;
							return false;
						}
						value = value5;
						break;
					}
					case BinaryEntryType.NamedByte:
					case BinaryEntryType.UnnamedByte:
					{
						if (!UNSAFE_Read_1_Byte(out var value6))
						{
							value = 0L;
							return false;
						}
						value = value6;
						break;
					}
					case BinaryEntryType.NamedShort:
					case BinaryEntryType.UnnamedShort:
					{
						if (!UNSAFE_Read_2_Int16(out var value7))
						{
							value = 0L;
							return false;
						}
						value = value7;
						break;
					}
					case BinaryEntryType.NamedUShort:
					case BinaryEntryType.UnnamedUShort:
					{
						if (!UNSAFE_Read_2_UInt16(out var value3))
						{
							value = 0L;
							return false;
						}
						value = value3;
						break;
					}
					case BinaryEntryType.NamedInt:
					case BinaryEntryType.UnnamedInt:
					{
						if (!UNSAFE_Read_4_Int32(out var value4))
						{
							value = 0L;
							return false;
						}
						value = value4;
						break;
					}
					case BinaryEntryType.NamedUInt:
					case BinaryEntryType.UnnamedUInt:
					{
						if (!UNSAFE_Read_4_UInt32(out var value8))
						{
							value = 0L;
							return false;
						}
						value = value8;
						break;
					}
					case BinaryEntryType.NamedLong:
					case BinaryEntryType.UnnamedLong:
						if (!UNSAFE_Read_8_Int64(out value))
						{
							return false;
						}
						break;
					case BinaryEntryType.NamedULong:
					case BinaryEntryType.UnnamedULong:
					{
						if (!UNSAFE_Read_8_UInt64(out var value2))
						{
							value = 0L;
							return false;
						}
						if (value2 > long.MaxValue)
						{
							value = 0L;
							return false;
						}
						value = (long)value2;
						break;
					}
					default:
						throw new InvalidOperationException();
					}
					return true;
				}
				finally
				{
					MarkEntryContentConsumed();
				}
			}
			SkipEntry();
			value = 0L;
			return false;
		}

		public override bool ReadUInt64(out ulong value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedEntryType == EntryType.Integer)
			{
				try
				{
					switch (peekedBinaryEntryType)
					{
					case BinaryEntryType.NamedSByte:
					case BinaryEntryType.UnnamedSByte:
					case BinaryEntryType.NamedByte:
					case BinaryEntryType.UnnamedByte:
					{
						if (!UNSAFE_Read_1_Byte(out var value7))
						{
							value = 0uL;
							return false;
						}
						value = value7;
						break;
					}
					case BinaryEntryType.NamedShort:
					case BinaryEntryType.UnnamedShort:
					{
						if (!UNSAFE_Read_2_Int16(out var value4))
						{
							value = 0uL;
							return false;
						}
						if (value4 < 0)
						{
							value = 0uL;
							return false;
						}
						value = (ulong)value4;
						break;
					}
					case BinaryEntryType.NamedUShort:
					case BinaryEntryType.UnnamedUShort:
					{
						if (!UNSAFE_Read_2_UInt16(out var value6))
						{
							value = 0uL;
							return false;
						}
						value = value6;
						break;
					}
					case BinaryEntryType.NamedInt:
					case BinaryEntryType.UnnamedInt:
					{
						if (!UNSAFE_Read_4_Int32(out var value5))
						{
							value = 0uL;
							return false;
						}
						if (value5 < 0)
						{
							value = 0uL;
							return false;
						}
						value = (ulong)value5;
						break;
					}
					case BinaryEntryType.NamedUInt:
					case BinaryEntryType.UnnamedUInt:
					{
						if (!UNSAFE_Read_4_UInt32(out var value2))
						{
							value = 0uL;
							return false;
						}
						value = value2;
						break;
					}
					case BinaryEntryType.NamedLong:
					case BinaryEntryType.UnnamedLong:
					{
						if (!UNSAFE_Read_8_Int64(out var value3))
						{
							value = 0uL;
							return false;
						}
						if (value3 < 0)
						{
							value = 0uL;
							return false;
						}
						value = (ulong)value3;
						break;
					}
					case BinaryEntryType.NamedULong:
					case BinaryEntryType.UnnamedULong:
						if (!UNSAFE_Read_8_UInt64(out value))
						{
							return false;
						}
						break;
					default:
						throw new InvalidOperationException();
					}
					return true;
				}
				finally
				{
					MarkEntryContentConsumed();
				}
			}
			SkipEntry();
			value = 0uL;
			return false;
		}

		public override bool ReadChar(out char value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedChar || peekedBinaryEntryType == BinaryEntryType.UnnamedChar)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_2_Char(out value);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedString || peekedBinaryEntryType == BinaryEntryType.UnnamedString)
			{
				MarkEntryContentConsumed();
				string text = ReadStringValue();
				if (text == null || text.Length == 0)
				{
					value = '\0';
					return false;
				}
				value = text[0];
				return true;
			}
			SkipEntry();
			value = '\0';
			return false;
		}

		public override bool ReadSingle(out float value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedFloat || peekedBinaryEntryType == BinaryEntryType.UnnamedFloat)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_4_Float32(out value);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedDouble || peekedBinaryEntryType == BinaryEntryType.UnnamedDouble)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_8_Float64(out var value2))
				{
					value = 0f;
					return false;
				}
				try
				{
					value = (float)value2;
				}
				catch (OverflowException)
				{
					value = 0f;
				}
				return true;
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedDecimal || peekedBinaryEntryType == BinaryEntryType.UnnamedDecimal)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_16_Decimal(out var value3))
				{
					value = 0f;
					return false;
				}
				try
				{
					value = (float)value3;
				}
				catch (OverflowException)
				{
					value = 0f;
				}
				return true;
			}
			if (peekedEntryType == EntryType.Integer)
			{
				if (!ReadInt64(out var value4))
				{
					value = 0f;
					return false;
				}
				try
				{
					value = value4;
				}
				catch (OverflowException)
				{
					value = 0f;
				}
				return true;
			}
			SkipEntry();
			value = 0f;
			return false;
		}

		public override bool ReadDouble(out double value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedDouble || peekedBinaryEntryType == BinaryEntryType.UnnamedDouble)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_8_Float64(out value);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedFloat || peekedBinaryEntryType == BinaryEntryType.UnnamedFloat)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_4_Float32(out var value2))
				{
					value = 0.0;
					return false;
				}
				value = value2;
				return true;
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedDecimal || peekedBinaryEntryType == BinaryEntryType.UnnamedDecimal)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_16_Decimal(out var value3))
				{
					value = 0.0;
					return false;
				}
				try
				{
					value = (double)value3;
				}
				catch (OverflowException)
				{
					value = 0.0;
				}
				return true;
			}
			if (peekedEntryType == EntryType.Integer)
			{
				if (!ReadInt64(out var value4))
				{
					value = 0.0;
					return false;
				}
				try
				{
					value = value4;
				}
				catch (OverflowException)
				{
					value = 0.0;
				}
				return true;
			}
			SkipEntry();
			value = 0.0;
			return false;
		}

		public override bool ReadDecimal(out decimal value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedDecimal || peekedBinaryEntryType == BinaryEntryType.UnnamedDecimal)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_16_Decimal(out value);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedDouble || peekedBinaryEntryType == BinaryEntryType.UnnamedDouble)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_8_Float64(out var value2))
				{
					value = default(decimal);
					return false;
				}
				try
				{
					value = (decimal)value2;
				}
				catch (OverflowException)
				{
					value = default(decimal);
				}
				return true;
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedFloat || peekedBinaryEntryType == BinaryEntryType.UnnamedFloat)
			{
				MarkEntryContentConsumed();
				if (!UNSAFE_Read_4_Float32(out var value3))
				{
					value = default(decimal);
					return false;
				}
				try
				{
					value = (decimal)value3;
				}
				catch (OverflowException)
				{
					value = default(decimal);
				}
				return true;
			}
			if (peekedEntryType == EntryType.Integer)
			{
				if (!ReadInt64(out var value4))
				{
					value = default(decimal);
					return false;
				}
				try
				{
					value = value4;
				}
				catch (OverflowException)
				{
					value = default(decimal);
				}
				return true;
			}
			SkipEntry();
			value = default(decimal);
			return false;
		}

		public override bool ReadExternalReference(out Guid guid)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedExternalReferenceByGuid || peekedBinaryEntryType == BinaryEntryType.UnnamedExternalReferenceByGuid)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_16_Guid(out guid);
			}
			SkipEntry();
			guid = default(Guid);
			return false;
		}

		public override bool ReadGuid(out Guid value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedGuid || peekedBinaryEntryType == BinaryEntryType.UnnamedGuid)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_16_Guid(out value);
			}
			SkipEntry();
			value = default(Guid);
			return false;
		}

		public override bool ReadExternalReference(out int index)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedExternalReferenceByIndex || peekedBinaryEntryType == BinaryEntryType.UnnamedExternalReferenceByIndex)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_4_Int32(out index);
			}
			SkipEntry();
			index = -1;
			return false;
		}

		public override bool ReadExternalReference(out string id)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedExternalReferenceByString || peekedBinaryEntryType == BinaryEntryType.UnnamedExternalReferenceByString)
			{
				id = ReadStringValue();
				MarkEntryContentConsumed();
				return id != null;
			}
			SkipEntry();
			id = null;
			return false;
		}

		public override bool ReadNull()
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedNull || peekedBinaryEntryType == BinaryEntryType.UnnamedNull)
			{
				MarkEntryContentConsumed();
				return true;
			}
			SkipEntry();
			return false;
		}

		public override bool ReadInternalReference(out int id)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedInternalReference || peekedBinaryEntryType == BinaryEntryType.UnnamedInternalReference)
			{
				MarkEntryContentConsumed();
				return UNSAFE_Read_4_Int32(out id);
			}
			SkipEntry();
			id = -1;
			return false;
		}

		public override bool ReadString(out string value)
		{
			if (!peekedEntryType.HasValue)
			{
				PeekEntry(out var _);
			}
			if (peekedBinaryEntryType == BinaryEntryType.NamedString || peekedBinaryEntryType == BinaryEntryType.UnnamedString)
			{
				value = ReadStringValue();
				MarkEntryContentConsumed();
				return value != null;
			}
			SkipEntry();
			value = null;
			return false;
		}

		public override void PrepareNewSerializationSession()
		{
			base.PrepareNewSerializationSession();
			peekedEntryType = null;
			peekedEntryName = null;
			peekedBinaryEntryType = BinaryEntryType.Invalid;
			types.Clear();
			bufferIndex = 0;
			bufferEnd = 0;
			buffer = internalBufferBackup;
		}

		public unsafe override string GetDataDump()
		{
			byte[] array;
			if (bufferEnd == buffer.Length)
			{
				array = buffer;
			}
			else
			{
				array = new byte[bufferEnd];
				fixed (byte* ptr = buffer)
				{
					void* from = ptr;
					fixed (byte* ptr2 = array)
					{
						void* to = ptr2;
						UnsafeUtilities.MemoryCopy(from, to, array.Length);
					}
				}
			}
			return "Binary hex dump: " + ProperBitConverter.BytesToHexString(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe string ReadStringValue()
		{
			if (!UNSAFE_Read_1_Byte(out var value))
			{
				return null;
			}
			if (!UNSAFE_Read_4_Int32(out var value2))
			{
				return null;
			}
			string text = new string(' ', value2);
			if (value == 0)
			{
				fixed (byte* ptr = buffer)
				{
					fixed (char* ptr3 = text)
					{
						byte* ptr2 = ptr + bufferIndex;
						byte* ptr4 = (byte*)ptr3;
						if (BitConverter.IsLittleEndian)
						{
							for (int i = 0; i < value2; i++)
							{
								*(ptr4++) = *(ptr2++);
								ptr4++;
							}
						}
						else
						{
							for (int j = 0; j < value2; j++)
							{
								ptr4++;
								*(ptr4++) = *(ptr2++);
							}
						}
					}
				}
				bufferIndex += value2;
				return text;
			}
			int num = value2 * 2;
			fixed (byte* ptr5 = buffer)
			{
				fixed (char* ptr7 = text)
				{
					if (BitConverter.IsLittleEndian)
					{
						Struct256Bit* ptr6 = (Struct256Bit*)(ptr5 + bufferIndex);
						Struct256Bit* ptr8 = (Struct256Bit*)ptr7;
						byte* ptr9 = (byte*)ptr7 + num;
						while (ptr8 + 1 < ptr9)
						{
							*(ptr8++) = *(ptr6++);
						}
						byte* ptr10 = (byte*)ptr6;
						byte* ptr11 = (byte*)ptr8;
						while (ptr11 < ptr9)
						{
							*(ptr11++) = *(ptr10++);
						}
					}
					else
					{
						byte* ptr12 = ptr5 + bufferIndex;
						byte* ptr13 = (byte*)ptr7;
						for (int k = 0; k < value2; k++)
						{
							*ptr13 = ptr12[1];
							ptr13[1] = *ptr12;
							ptr12 += 2;
							ptr13 += 2;
						}
					}
				}
			}
			bufferIndex += num;
			return text;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void SkipStringValue()
		{
			if (UNSAFE_Read_1_Byte(out var value) && UNSAFE_Read_4_Int32(out var value2))
			{
				if (value != 0)
				{
					value2 *= 2;
				}
				if (HasBufferData(value2))
				{
					bufferIndex += value2;
				}
				else
				{
					bufferIndex = bufferEnd;
				}
			}
		}

		private void SkipPeekedEntryContent()
		{
			if (!peekedEntryType.HasValue)
			{
				return;
			}
			try
			{
				switch (peekedBinaryEntryType)
				{
				case BinaryEntryType.NamedStartOfReferenceNode:
				case BinaryEntryType.UnnamedStartOfReferenceNode:
					ReadTypeEntry();
					if (SkipBuffer(4))
					{
					}
					break;
				case BinaryEntryType.NamedStartOfStructNode:
				case BinaryEntryType.UnnamedStartOfStructNode:
					ReadTypeEntry();
					break;
				case BinaryEntryType.StartOfArray:
					SkipBuffer(8);
					break;
				case BinaryEntryType.PrimitiveArray:
				{
					if (UNSAFE_Read_4_Int32(out var value) && UNSAFE_Read_4_Int32(out var value2))
					{
						SkipBuffer(value * value2);
					}
					break;
				}
				case BinaryEntryType.NamedSByte:
				case BinaryEntryType.UnnamedSByte:
				case BinaryEntryType.NamedByte:
				case BinaryEntryType.UnnamedByte:
				case BinaryEntryType.NamedBoolean:
				case BinaryEntryType.UnnamedBoolean:
					SkipBuffer(1);
					break;
				case BinaryEntryType.NamedShort:
				case BinaryEntryType.UnnamedShort:
				case BinaryEntryType.NamedUShort:
				case BinaryEntryType.UnnamedUShort:
				case BinaryEntryType.NamedChar:
				case BinaryEntryType.UnnamedChar:
					SkipBuffer(2);
					break;
				case BinaryEntryType.NamedInternalReference:
				case BinaryEntryType.UnnamedInternalReference:
				case BinaryEntryType.NamedExternalReferenceByIndex:
				case BinaryEntryType.UnnamedExternalReferenceByIndex:
				case BinaryEntryType.NamedInt:
				case BinaryEntryType.UnnamedInt:
				case BinaryEntryType.NamedUInt:
				case BinaryEntryType.UnnamedUInt:
				case BinaryEntryType.NamedFloat:
				case BinaryEntryType.UnnamedFloat:
					SkipBuffer(4);
					break;
				case BinaryEntryType.NamedLong:
				case BinaryEntryType.UnnamedLong:
				case BinaryEntryType.NamedULong:
				case BinaryEntryType.UnnamedULong:
				case BinaryEntryType.NamedDouble:
				case BinaryEntryType.UnnamedDouble:
					SkipBuffer(8);
					break;
				case BinaryEntryType.NamedExternalReferenceByGuid:
				case BinaryEntryType.UnnamedExternalReferenceByGuid:
				case BinaryEntryType.NamedDecimal:
				case BinaryEntryType.UnnamedDecimal:
				case BinaryEntryType.NamedGuid:
				case BinaryEntryType.UnnamedGuid:
					SkipBuffer(8);
					break;
				case BinaryEntryType.NamedString:
				case BinaryEntryType.UnnamedString:
				case BinaryEntryType.NamedExternalReferenceByString:
				case BinaryEntryType.UnnamedExternalReferenceByString:
					SkipStringValue();
					break;
				case BinaryEntryType.TypeName:
					base.Context.Config.DebugContext.LogError("Parsing error in binary data reader: should not be able to peek a TypeName entry.");
					SkipBuffer(4);
					ReadStringValue();
					break;
				case BinaryEntryType.TypeID:
					base.Context.Config.DebugContext.LogError("Parsing error in binary data reader: should not be able to peek a TypeID entry.");
					SkipBuffer(4);
					break;
				case BinaryEntryType.Invalid:
				case BinaryEntryType.EndOfNode:
				case BinaryEntryType.EndOfArray:
				case BinaryEntryType.NamedNull:
				case BinaryEntryType.UnnamedNull:
				case BinaryEntryType.EndOfStream:
					break;
				}
			}
			finally
			{
				MarkEntryContentConsumed();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool SkipBuffer(int amount)
		{
			int num = bufferIndex + amount;
			if (num > bufferEnd)
			{
				bufferIndex = bufferEnd;
				return false;
			}
			bufferIndex = num;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private Type ReadTypeEntry()
		{
			if (!HasBufferData(1))
			{
				return null;
			}
			BinaryEntryType binaryEntryType = (BinaryEntryType)buffer[bufferIndex++];
			int value2;
			Type value;
			switch (binaryEntryType)
			{
			case BinaryEntryType.TypeID:
				if (!UNSAFE_Read_4_Int32(out value2))
				{
					return null;
				}
				if (!types.TryGetValue(value2, out value))
				{
					base.Context.Config.DebugContext.LogError("Missing type ID during deserialization: " + value2 + " at node " + base.CurrentNodeName + " and depth " + base.CurrentNodeDepth + " and id " + base.CurrentNodeId);
				}
				break;
			case BinaryEntryType.TypeName:
			{
				if (!UNSAFE_Read_4_Int32(out value2))
				{
					return null;
				}
				string text = ReadStringValue();
				value = ((text == null) ? null : base.Context.Binder.BindToType(text, base.Context.Config.DebugContext));
				types.Add(value2, value);
				break;
			}
			case BinaryEntryType.UnnamedNull:
				value = null;
				break;
			default:
				value = null;
				base.Context.Config.DebugContext.LogError("Expected TypeName, TypeID or UnnamedNull entry flag for reading type data, but instead got the entry flag: " + binaryEntryType.ToString() + ".");
				break;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void MarkEntryContentConsumed()
		{
			peekedEntryType = null;
			peekedEntryName = null;
			peekedBinaryEntryType = BinaryEntryType.Invalid;
		}

		protected override EntryType PeekEntry()
		{
			string name;
			return PeekEntry(out name);
		}

		protected override EntryType ReadToNextEntry()
		{
			SkipPeekedEntryContent();
			string name;
			return PeekEntry(out name);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool UNSAFE_Read_1_Byte(out byte value)
		{
			if (HasBufferData(1))
			{
				value = buffer[bufferIndex++];
				return true;
			}
			value = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool UNSAFE_Read_1_SByte(out sbyte value)
		{
			if (HasBufferData(1))
			{
				value = (sbyte)buffer[bufferIndex++];
				return true;
			}
			value = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_2_Int16(out short value)
		{
			if (HasBufferData(2))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						value = *(short*)(ptr + bufferIndex);
					}
					else
					{
						short num = 0;
						byte* ptr2 = (byte*)(&num) + 1;
						byte* ptr3 = ptr + bufferIndex;
						*(ptr2--) = *(ptr3++);
						*ptr2 = *ptr3;
						value = num;
					}
				}
				bufferIndex += 2;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_2_UInt16(out ushort value)
		{
			if (HasBufferData(2))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						value = *(ushort*)(ptr + bufferIndex);
					}
					else
					{
						ushort num = 0;
						byte* ptr2 = (byte*)(&num) + 1;
						byte* ptr3 = ptr + bufferIndex;
						*(ptr2--) = *(ptr3++);
						*ptr2 = *ptr3;
						value = num;
					}
				}
				bufferIndex += 2;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_2_Char(out char value)
		{
			if (HasBufferData(2))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						value = *(char*)(ptr + bufferIndex);
					}
					else
					{
						char c = '\0';
						byte* ptr2 = (byte*)(&c) + 1;
						byte* ptr3 = ptr + bufferIndex;
						*(ptr2--) = *(ptr3++);
						*ptr2 = *ptr3;
						value = c;
					}
				}
				bufferIndex += 2;
				return true;
			}
			bufferIndex = bufferEnd;
			value = '\0';
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_4_Int32(out int value)
		{
			if (HasBufferData(4))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						value = *(int*)(ptr + bufferIndex);
					}
					else
					{
						int num = 0;
						byte* ptr2 = (byte*)(&num) + 3;
						byte* ptr3 = ptr + bufferIndex;
						*(ptr2--) = *(ptr3++);
						*(ptr2--) = *(ptr3++);
						*(ptr2--) = *(ptr3++);
						*ptr2 = *ptr3;
						value = num;
					}
				}
				bufferIndex += 4;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_4_UInt32(out uint value)
		{
			if (HasBufferData(4))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						value = *(uint*)(ptr + bufferIndex);
					}
					else
					{
						uint num = 0u;
						byte* ptr2 = (byte*)(&num) + 3;
						byte* ptr3 = ptr + bufferIndex;
						*(ptr2--) = *(ptr3++);
						*(ptr2--) = *(ptr3++);
						*(ptr2--) = *(ptr3++);
						*ptr2 = *ptr3;
						value = num;
					}
				}
				bufferIndex += 4;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0u;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_4_Float32(out float value)
		{
			if (HasBufferData(4))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						if (ArchitectureInfo.Architecture_Supports_Unaligned_Float32_Reads)
						{
							value = *(float*)(ptr + bufferIndex);
						}
						else
						{
							float num = 0f;
							*(int*)(&num) = *(int*)(ptr + bufferIndex);
							value = num;
						}
					}
					else
					{
						float num2 = 0f;
						byte* ptr2 = (byte*)(&num2) + 3;
						byte* ptr3 = ptr + bufferIndex;
						*(ptr2--) = *(ptr3++);
						*(ptr2--) = *(ptr3++);
						*(ptr2--) = *(ptr3++);
						*ptr2 = *ptr3;
						value = num2;
					}
				}
				bufferIndex += 4;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0f;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_8_Int64(out long value)
		{
			if (HasBufferData(8))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
						{
							value = *(long*)(ptr + bufferIndex);
						}
						else
						{
							long num = 0L;
							int* ptr2 = (int*)(&num);
							int* ptr3 = (int*)(ptr + bufferIndex);
							*(ptr2++) = *(ptr3++);
							*ptr2 = *ptr3;
							value = num;
						}
					}
					else
					{
						long num2 = 0L;
						byte* ptr4 = (byte*)(&num2) + 7;
						byte* ptr5 = ptr + bufferIndex;
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*ptr4 = *ptr5;
						value = num2;
					}
				}
				bufferIndex += 8;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0L;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_8_UInt64(out ulong value)
		{
			if (HasBufferData(8))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
						{
							value = *(ulong*)(ptr + bufferIndex);
						}
						else
						{
							ulong num = 0uL;
							int* ptr2 = (int*)(&num);
							int* ptr3 = (int*)(ptr + bufferIndex);
							*(ptr2++) = *(ptr3++);
							*ptr2 = *ptr3;
							value = num;
						}
					}
					else
					{
						ulong num2 = 0uL;
						byte* ptr4 = (byte*)(&num2) + 7;
						byte* ptr5 = ptr + bufferIndex;
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*ptr4 = *ptr5;
						value = num2;
					}
				}
				bufferIndex += 8;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0uL;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_8_Float64(out double value)
		{
			if (HasBufferData(8))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
						{
							value = *(double*)(ptr + bufferIndex);
						}
						else
						{
							double num = 0.0;
							int* ptr2 = (int*)(&num);
							int* ptr3 = (int*)(ptr + bufferIndex);
							*(ptr2++) = *(ptr3++);
							*ptr2 = *ptr3;
							value = num;
						}
					}
					else
					{
						double num2 = 0.0;
						byte* ptr4 = (byte*)(&num2) + 7;
						byte* ptr5 = ptr + bufferIndex;
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*ptr4 = *ptr5;
						value = num2;
					}
				}
				bufferIndex += 8;
				return true;
			}
			bufferIndex = bufferEnd;
			value = 0.0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_16_Decimal(out decimal value)
		{
			if (HasBufferData(16))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
						{
							value = *(decimal*)(ptr + bufferIndex);
						}
						else
						{
							decimal num = default(decimal);
							int* ptr2 = (int*)(&num);
							int* ptr3 = (int*)(ptr + bufferIndex);
							*(ptr2++) = *(ptr3++);
							*(ptr2++) = *(ptr3++);
							*(ptr2++) = *(ptr3++);
							*ptr2 = *ptr3;
							value = num;
						}
					}
					else
					{
						decimal num2 = default(decimal);
						byte* ptr4 = (byte*)(&num2) + 15;
						byte* ptr5 = ptr + bufferIndex;
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*ptr4 = *ptr5;
						value = num2;
					}
				}
				bufferIndex += 16;
				return true;
			}
			bufferIndex = bufferEnd;
			value = default(decimal);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool UNSAFE_Read_16_Guid(out Guid value)
		{
			if (HasBufferData(16))
			{
				fixed (byte* ptr = buffer)
				{
					if (BitConverter.IsLittleEndian)
					{
						if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
						{
							value = *(Guid*)(ptr + bufferIndex);
						}
						else
						{
							Guid guid = default(Guid);
							int* ptr2 = (int*)(&guid);
							int* ptr3 = (int*)(ptr + bufferIndex);
							*(ptr2++) = *(ptr3++);
							*(ptr2++) = *(ptr3++);
							*(ptr2++) = *(ptr3++);
							*ptr2 = *ptr3;
							value = guid;
						}
					}
					else
					{
						Guid guid2 = default(Guid);
						byte* ptr4 = (byte*)(&guid2);
						byte* ptr5 = ptr + bufferIndex;
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*(ptr4++) = *(ptr5++);
						*ptr4 = *(ptr5++);
						ptr4 += 6;
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*(ptr4--) = *(ptr5++);
						*ptr4 = *ptr5;
						value = guid2;
					}
				}
				bufferIndex += 16;
				return true;
			}
			bufferIndex = bufferEnd;
			value = default(Guid);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool HasBufferData(int amount)
		{
			if (bufferEnd == 0)
			{
				ReadEntireStreamToBuffer();
			}
			return bufferIndex + amount <= bufferEnd;
		}

		private void ReadEntireStreamToBuffer()
		{
			bufferIndex = 0;
			if (Stream is MemoryStream)
			{
				try
				{
					buffer = (Stream as MemoryStream).GetBuffer();
					bufferEnd = (int)Stream.Length;
					bufferIndex = (int)Stream.Position;
					return;
				}
				catch (UnauthorizedAccessException)
				{
				}
			}
			buffer = internalBufferBackup;
			int num = (int)(Stream.Length - Stream.Position);
			if (buffer.Length >= num)
			{
				Stream.Read(buffer, 0, num);
			}
			else
			{
				buffer = new byte[num];
				Stream.Read(buffer, 0, num);
				if (num <= 10485760)
				{
					internalBufferBackup = buffer;
				}
			}
			bufferIndex = 0;
			bufferEnd = num;
		}
	}
	public class BinaryDataWriter : BaseDataWriter
	{
		private struct Struct256Bit
		{
			public decimal d1;

			public decimal d2;
		}

		[StructLayout(LayoutKind.Explicit, Size = 8)]
		private struct SixtyFourBitValueToByteUnion
		{
			[FieldOffset(0)]
			public byte b0;

			[FieldOffset(1)]
			public byte b1;

			[FieldOffset(2)]
			public byte b2;

			[FieldOffset(3)]
			public byte b3;

			[FieldOffset(4)]
			public byte b4;

			[FieldOffset(5)]
			public byte b5;

			[FieldOffset(6)]
			public byte b6;

			[FieldOffset(7)]
			public byte b7;

			[FieldOffset(0)]
			public double doubleValue;

			[FieldOffset(0)]
			public ulong ulongValue;

			[FieldOffset(0)]
			public long longValue;
		}

		[StructLayout(LayoutKind.Explicit, Size = 16)]
		private struct OneTwentyEightBitValueToByteUnion
		{
			[FieldOffset(0)]
			public byte b0;

			[FieldOffset(1)]
			public byte b1;

			[FieldOffset(2)]
			public byte b2;

			[FieldOffset(3)]
			public byte b3;

			[FieldOffset(4)]
			public byte b4;

			[FieldOffset(5)]
			public byte b5;

			[FieldOffset(6)]
			public byte b6;

			[FieldOffset(7)]
			public byte b7;

			[FieldOffset(8)]
			public byte b8;

			[FieldOffset(9)]
			public byte b9;

			[FieldOffset(10)]
			public byte b10;

			[FieldOffset(11)]
			public byte b11;

			[FieldOffset(12)]
			public byte b12;

			[FieldOffset(13)]
			public byte b13;

			[FieldOffset(14)]
			public byte b14;

			[FieldOffset(15)]
			public byte b15;

			[FieldOffset(0)]
			public Guid guidValue;

			[FieldOffset(0)]
			public decimal decimalValue;
		}

		private static readonly Dictionary<Type, Delegate> PrimitiveGetBytesMethods = new Dictionary<Type, Delegate>(FastTypeComparer.Instance)
		{
			{
				typeof(char),
				(Action<byte[], int, char>)delegate(byte[] b, int i, char v)
				{
					ProperBitConverter.GetBytes(b, i, v);
				}
			},
			{
				typeof(byte),
				(Action<byte[], int, byte>)delegate(byte[] b, int i, byte v)
				{
					b[i] = v;
				}
			},
			{
				typeof(sbyte),
				(Action<byte[], int, sbyte>)delegate(byte[] b, int i, sbyte v)
				{
					b[i] = (byte)v;
				}
			},
			{
				typeof(bool),
				(Action<byte[], int, bool>)delegate(byte[] b, int i, bool v)
				{
					b[i] = (v ? ((byte)1) : ((byte)0));
				}
			},
			{
				typeof(short),
				new Action<byte[], int, short>(ProperBitConverter.GetBytes)
			},
			{
				typeof(int),
				new Action<byte[], int, int>(ProperBitConverter.GetBytes)
			},
			{
				typeof(long),
				new Action<byte[], int, long>(ProperBitConverter.GetBytes)
			},
			{
				typeof(ushort),
				new Action<byte[], int, ushort>(ProperBitConverter.GetBytes)
			},
			{
				typeof(uint),
				new Action<byte[], int, uint>(ProperBitConverter.GetBytes)
			},
			{
				typeof(ulong),
				new Action<byte[], int, ulong>(ProperBitConverter.GetBytes)
			},
			{
				typeof(decimal),
				new Action<byte[], int, decimal>(ProperBitConverter.GetBytes)
			},
			{
				typeof(float),
				new Action<byte[], int, float>(ProperBitConverter.GetBytes)
			},
			{
				typeof(double),
				new Action<byte[], int, double>(ProperBitConverter.GetBytes)
			},
			{
				typeof(Guid),
				new Action<byte[], int, Guid>(ProperBitConverter.GetBytes)
			}
		};

		private static readonly Dictionary<Type, int> PrimitiveSizes = new Dictionary<Type, int>(FastTypeComparer.Instance)
		{
			{
				typeof(char),
				2
			},
			{
				typeof(byte),
				1
			},
			{
				typeof(sbyte),
				1
			},
			{
				typeof(bool),
				1
			},
			{
				typeof(short),
				2
			},
			{
				typeof(int),
				4
			},
			{
				typeof(long),
				8
			},
			{
				typeof(ushort),
				2
			},
			{
				typeof(uint),
				4
			},
			{
				typeof(ulong),
				8
			},
			{
				typeof(decimal),
				16
			},
			{
				typeof(float),
				4
			},
			{
				typeof(double),
				8
			},
			{
				typeof(Guid),
				16
			}
		};

		private readonly byte[] small_buffer = new byte[16];

		private readonly byte[] buffer = new byte[102400];

		private int bufferIndex;

		private readonly Dictionary<Type, int> types = new Dictionary<Type, int>(16, FastTypeComparer.Instance);

		public bool CompressStringsTo8BitWhenPossible;

		private static readonly Dictionary<Type, Action<BinaryDataWriter, object>> PrimitiveArrayWriters = new Dictionary<Type, Action<BinaryDataWriter, object>>(FastTypeComparer.Instance)
		{
			{
				typeof(char),
				WritePrimitiveArray_char
			},
			{
				typeof(sbyte),
				WritePrimitiveArray_sbyte
			},
			{
				typeof(short),
				WritePrimitiveArray_short
			},
			{
				typeof(int),
				WritePrimitiveArray_int
			},
			{
				typeof(long),
				WritePrimitiveArray_long
			},
			{
				typeof(byte),
				WritePrimitiveArray_byte
			},
			{
				typeof(ushort),
				WritePrimitiveArray_ushort
			},
			{
				typeof(uint),
				WritePrimitiveArray_uint
			},
			{
				typeof(ulong),
				WritePrimitiveArray_ulong
			},
			{
				typeof(decimal),
				WritePrimitiveArray_decimal
			},
			{
				typeof(bool),
				WritePrimitiveArray_bool
			},
			{
				typeof(float),
				WritePrimitiveArray_float
			},
			{
				typeof(double),
				WritePrimitiveArray_double
			},
			{
				typeof(Guid),
				WritePrimitiveArray_Guid
			}
		};

		public BinaryDataWriter()
			: base(null, null)
		{
		}

		public BinaryDataWriter(Stream stream, SerializationContext context)
			: base(stream, context)
		{
		}

		public override void BeginArrayNode(long length)
		{
			EnsureBufferSpace(9);
			buffer[bufferIndex++] = 6;
			UNSAFE_WriteToBuffer_8_Int64(length);
			PushArray();
		}

		public override void BeginReferenceNode(string name, Type type, int id)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 1;
				WriteStringFast(name);
			}
			else
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 2;
			}
			WriteType(type);
			EnsureBufferSpace(4);
			UNSAFE_WriteToBuffer_4_Int32(id);
			PushNode(name, id, type);
		}

		public override void BeginStructNode(string name, Type type)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 3;
				WriteStringFast(name);
			}
			else
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 4;
			}
			WriteType(type);
			PushNode(name, -1, type);
		}

		public override void Dispose()
		{
			FlushToStream();
		}

		public override void EndArrayNode()
		{
			PopArray();
			EnsureBufferSpace(1);
			buffer[bufferIndex++] = 7;
		}

		public override void EndNode(string name)
		{
			PopNode(name);
			EnsureBufferSpace(1);
			buffer[bufferIndex++] = 5;
		}

		private static void WritePrimitiveArray_byte(BinaryDataWriter writer, object o)
		{
			byte[] array = o as byte[];
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(1);
			writer.FlushToStream();
			writer.Stream.Write(array, 0, array.Length);
		}

		private unsafe static void WritePrimitiveArray_sbyte(BinaryDataWriter writer, object o)
		{
			sbyte[] array = o as sbyte[];
			int num = 1;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				fixed (byte* ptr2 = writer.buffer)
				{
					fixed (sbyte* ptr = array)
					{
						void* from = ptr;
						void* to = ptr2 + writer.bufferIndex;
						UnsafeUtilities.MemoryCopy(from, to, num2);
					}
				}
				writer.bufferIndex += num2;
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_bool(BinaryDataWriter writer, object o)
		{
			bool[] array = o as bool[];
			int num = 1;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				fixed (byte* ptr2 = writer.buffer)
				{
					fixed (bool* ptr = array)
					{
						void* from = ptr;
						void* to = ptr2 + writer.bufferIndex;
						UnsafeUtilities.MemoryCopy(from, to, num2);
					}
				}
				writer.bufferIndex += num2;
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_char(BinaryDataWriter writer, object o)
		{
			char[] array = o as char[];
			int num = 2;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (char* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_2_Char(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_short(BinaryDataWriter writer, object o)
		{
			short[] array = o as short[];
			int num = 2;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (short* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_2_Int16(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_int(BinaryDataWriter writer, object o)
		{
			int[] array = o as int[];
			int num = 4;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (int* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_4_Int32(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_long(BinaryDataWriter writer, object o)
		{
			long[] array = o as long[];
			int num = 8;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (long* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_8_Int64(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_ushort(BinaryDataWriter writer, object o)
		{
			ushort[] array = o as ushort[];
			int num = 2;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (ushort* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_2_UInt16(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_uint(BinaryDataWriter writer, object o)
		{
			uint[] array = o as uint[];
			int num = 4;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (uint* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_4_UInt32(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_ulong(BinaryDataWriter writer, object o)
		{
			ulong[] array = o as ulong[];
			int num = 8;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (ulong* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_8_UInt64(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_decimal(BinaryDataWriter writer, object o)
		{
			decimal[] array = o as decimal[];
			int num = 16;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (decimal* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_16_Decimal(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_float(BinaryDataWriter writer, object o)
		{
			float[] array = o as float[];
			int num = 4;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (float* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_4_Float32(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_double(BinaryDataWriter writer, object o)
		{
			double[] array = o as double[];
			int num = 8;
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (double* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_8_Float64(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		private unsafe static void WritePrimitiveArray_Guid(BinaryDataWriter writer, object o)
		{
			Guid[] array = o as Guid[];
			int num = sizeof(Guid);
			int num2 = array.Length * num;
			writer.EnsureBufferSpace(9);
			writer.buffer[writer.bufferIndex++] = 8;
			writer.UNSAFE_WriteToBuffer_4_Int32(array.Length);
			writer.UNSAFE_WriteToBuffer_4_Int32(num);
			if (writer.TryEnsureBufferSpace(num2))
			{
				if (BitConverter.IsLittleEndian)
				{
					fixed (byte* ptr2 = writer.buffer)
					{
						fixed (Guid* ptr = array)
						{
							void* from = ptr;
							void* to = ptr2 + writer.bufferIndex;
							UnsafeUtilities.MemoryCopy(from, to, num2);
						}
					}
					writer.bufferIndex += num2;
				}
				else
				{
					for (int i = 0; i < array.Length; i++)
					{
						writer.UNSAFE_WriteToBuffer_16_Guid(array[i]);
					}
				}
				return;
			}
			writer.FlushToStream();
			using Buffer<byte> buffer = Buffer<byte>.Claim(num2);
			if (BitConverter.IsLittleEndian)
			{
				UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0);
			}
			else
			{
				byte[] array2 = buffer.Array;
				for (int j = 0; j < array.Length; j++)
				{
					ProperBitConverter.GetBytes(array2, j * num, array[j]);
				}
			}
			writer.Stream.Write(buffer.Array, 0, num2);
		}

		public override void WritePrimitiveArray<T>(T[] array)
		{
			if (!PrimitiveArrayWriters.TryGetValue(typeof(T), out var value))
			{
				throw new ArgumentException("Type " + typeof(T).Name + " is not a valid primitive array type.");
			}
			value(this, array);
		}

		public override void WriteBoolean(string name, bool value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 43;
				WriteStringFast(name);
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = (value ? ((byte)1) : ((byte)0));
			}
			else
			{
				EnsureBufferSpace(2);
				buffer[bufferIndex++] = 44;
				buffer[bufferIndex++] = (value ? ((byte)1) : ((byte)0));
			}
		}

		public override void WriteByte(string name, byte value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 17;
				WriteStringFast(name);
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = value;
			}
			else
			{
				EnsureBufferSpace(2);
				buffer[bufferIndex++] = 18;
				buffer[bufferIndex++] = value;
			}
		}

		public override void WriteChar(string name, char value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 37;
				WriteStringFast(name);
				EnsureBufferSpace(2);
				UNSAFE_WriteToBuffer_2_Char(value);
			}
			else
			{
				EnsureBufferSpace(3);
				buffer[bufferIndex++] = 38;
				UNSAFE_WriteToBuffer_2_Char(value);
			}
		}

		public override void WriteDecimal(string name, decimal value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 35;
				WriteStringFast(name);
				EnsureBufferSpace(16);
				UNSAFE_WriteToBuffer_16_Decimal(value);
			}
			else
			{
				EnsureBufferSpace(17);
				buffer[bufferIndex++] = 36;
				UNSAFE_WriteToBuffer_16_Decimal(value);
			}
		}

		public override void WriteDouble(string name, double value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 33;
				WriteStringFast(name);
				EnsureBufferSpace(8);
				UNSAFE_WriteToBuffer_8_Float64(value);
			}
			else
			{
				EnsureBufferSpace(9);
				buffer[bufferIndex++] = 34;
				UNSAFE_WriteToBuffer_8_Float64(value);
			}
		}

		public override void WriteGuid(string name, Guid value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 41;
				WriteStringFast(name);
				EnsureBufferSpace(16);
				UNSAFE_WriteToBuffer_16_Guid(value);
			}
			else
			{
				EnsureBufferSpace(17);
				buffer[bufferIndex++] = 42;
				UNSAFE_WriteToBuffer_16_Guid(value);
			}
		}

		public override void WriteExternalReference(string name, Guid guid)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 13;
				WriteStringFast(name);
				EnsureBufferSpace(16);
				UNSAFE_WriteToBuffer_16_Guid(guid);
			}
			else
			{
				EnsureBufferSpace(17);
				buffer[bufferIndex++] = 14;
				UNSAFE_WriteToBuffer_16_Guid(guid);
			}
		}

		public override void WriteExternalReference(string name, int index)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 11;
				WriteStringFast(name);
				EnsureBufferSpace(4);
				UNSAFE_WriteToBuffer_4_Int32(index);
			}
			else
			{
				EnsureBufferSpace(5);
				buffer[bufferIndex++] = 12;
				UNSAFE_WriteToBuffer_4_Int32(index);
			}
		}

		public override void WriteExternalReference(string name, string id)
		{
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 50;
				WriteStringFast(name);
			}
			else
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 51;
			}
			WriteStringFast(id);
		}

		public override void WriteInt32(string name, int value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 23;
				WriteStringFast(name);
				EnsureBufferSpace(4);
				UNSAFE_WriteToBuffer_4_Int32(value);
			}
			else
			{
				EnsureBufferSpace(5);
				buffer[bufferIndex++] = 24;
				UNSAFE_WriteToBuffer_4_Int32(value);
			}
		}

		public override void WriteInt64(string name, long value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 27;
				WriteStringFast(name);
				EnsureBufferSpace(8);
				UNSAFE_WriteToBuffer_8_Int64(value);
			}
			else
			{
				EnsureBufferSpace(9);
				buffer[bufferIndex++] = 28;
				UNSAFE_WriteToBuffer_8_Int64(value);
			}
		}

		public override void WriteNull(string name)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 45;
				WriteStringFast(name);
			}
			else
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 46;
			}
		}

		public override void WriteInternalReference(string name, int id)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 9;
				WriteStringFast(name);
				EnsureBufferSpace(4);
				UNSAFE_WriteToBuffer_4_Int32(id);
			}
			else
			{
				EnsureBufferSpace(5);
				buffer[bufferIndex++] = 10;
				UNSAFE_WriteToBuffer_4_Int32(id);
			}
		}

		public override void WriteSByte(string name, sbyte value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 15;
				WriteStringFast(name);
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = (byte)value;
			}
			else
			{
				EnsureBufferSpace(2);
				buffer[bufferIndex++] = 16;
				buffer[bufferIndex++] = (byte)value;
			}
		}

		public override void WriteInt16(string name, short value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 19;
				WriteStringFast(name);
				EnsureBufferSpace(2);
				UNSAFE_WriteToBuffer_2_Int16(value);
			}
			else
			{
				EnsureBufferSpace(3);
				buffer[bufferIndex++] = 20;
				UNSAFE_WriteToBuffer_2_Int16(value);
			}
		}

		public override void WriteSingle(string name, float value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 31;
				WriteStringFast(name);
				EnsureBufferSpace(4);
				UNSAFE_WriteToBuffer_4_Float32(value);
			}
			else
			{
				EnsureBufferSpace(5);
				buffer[bufferIndex++] = 32;
				UNSAFE_WriteToBuffer_4_Float32(value);
			}
		}

		public override void WriteString(string name, string value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 39;
				WriteStringFast(name);
			}
			else
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 40;
			}
			WriteStringFast(value);
		}

		public override void WriteUInt32(string name, uint value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 25;
				WriteStringFast(name);
				EnsureBufferSpace(4);
				UNSAFE_WriteToBuffer_4_UInt32(value);
			}
			else
			{
				EnsureBufferSpace(5);
				buffer[bufferIndex++] = 26;
				UNSAFE_WriteToBuffer_4_UInt32(value);
			}
		}

		public override void WriteUInt64(string name, ulong value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 29;
				WriteStringFast(name);
				EnsureBufferSpace(8);
				UNSAFE_WriteToBuffer_8_UInt64(value);
			}
			else
			{
				EnsureBufferSpace(9);
				buffer[bufferIndex++] = 30;
				UNSAFE_WriteToBuffer_8_UInt64(value);
			}
		}

		public override void WriteUInt16(string name, ushort value)
		{
			if (name != null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 21;
				WriteStringFast(name);
				EnsureBufferSpace(2);
				UNSAFE_WriteToBuffer_2_UInt16(value);
			}
			else
			{
				EnsureBufferSpace(3);
				buffer[bufferIndex++] = 22;
				UNSAFE_WriteToBuffer_2_UInt16(value);
			}
		}

		public override void PrepareNewSerializationSession()
		{
			base.PrepareNewSerializationSession();
			types.Clear();
			bufferIndex = 0;
		}

		public override string GetDataDump()
		{
			if (!Stream.CanRead)
			{
				return "Binary data stream for writing cannot be read; cannot dump data.";
			}
			if (!Stream.CanSeek)
			{
				return "Binary data stream cannot seek; cannot dump data.";
			}
			FlushToStream();
			long position = Stream.Position;
			byte[] bytes = new byte[position];
			Stream.Position = 0L;
			Stream.Read(bytes, 0, (int)position);
			Stream.Position = position;
			return "Binary hex dump: " + ProperBitConverter.BytesToHexString(bytes);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void WriteType(Type type)
		{
			if (type == null)
			{
				EnsureBufferSpace(1);
				buffer[bufferIndex++] = 46;
				return;
			}
			if (types.TryGetValue(type, out var value))
			{
				EnsureBufferSpace(5);
				buffer[bufferIndex++] = 48;
				UNSAFE_WriteToBuffer_4_Int32(value);
				return;
			}
			value = types.Count;
			types.Add(type, value);
			EnsureBufferSpace(5);
			buffer[bufferIndex++] = 47;
			UNSAFE_WriteToBuffer_4_Int32(value);
			WriteStringFast(base.Context.Binder.BindToName(type, base.Context.Config.DebugContext));
		}

		private unsafe void WriteStringFast(string value)
		{
			bool flag = true;
			if (CompressStringsTo8BitWhenPossible)
			{
				flag = false;
				for (int i = 0; i < value.Length; i++)
				{
					if (value[i] > 'ÿ')
					{
						flag = true;
						break;
					}
				}
			}
			int num;
			if (flag)
			{
				num = value.Length * 2;
				if (TryEnsureBufferSpace(num + 5))
				{
					this.buffer[bufferIndex++] = 1;
					UNSAFE_WriteToBuffer_4_Int32(value.Length);
					if (BitConverter.IsLittleEndian)
					{
						fixed (byte* ptr = this.buffer)
						{
							fixed (char* ptr3 = value)
							{
								Struct256Bit* ptr2 = (Struct256Bit*)(ptr + bufferIndex);
								Struct256Bit* ptr4 = (Struct256Bit*)ptr3;
								byte* ptr5 = (byte*)ptr2 + num;
								while (ptr2 + 1 <= ptr5)
								{
									*(ptr2++) = *(ptr4++);
								}
								char* ptr6 = (char*)ptr2;
								char* ptr7 = (char*)ptr4;
								while (ptr6 < ptr5)
								{
									*(ptr6++) = *(ptr7++);
								}
							}
						}
					}
					else
					{
						fixed (byte* ptr8 = this.buffer)
						{
							fixed (char* ptr10 = value)
							{
								byte* ptr9 = ptr8 + bufferIndex;
								byte* ptr11 = (byte*)ptr10;
								for (int j = 0; j < num; j += 2)
								{
									*ptr9 = ptr11[1];
									ptr9[1] = *ptr11;
									ptr11 += 2;
									ptr9 += 2;
								}
							}
						}
					}
					bufferIndex += num;
					return;
				}
				FlushToStream();
				Stream.WriteByte(1);
				ProperBitConverter.GetBytes(small_buffer, 0, value.Length);
				Stream.Write(small_buffer, 0, 4);
				using Buffer<byte> buffer = Buffer<byte>.Claim(num);
				byte[] array = buffer.Array;
				UnsafeUtilities.StringToBytes(array, value, needs16BitSupport: true);
				Stream.Write(array, 0, num);
				return;
			}
			num = value.Length;
			if (TryEnsureBufferSpace(num + 5))
			{
				this.buffer[bufferIndex++] = 0;
				UNSAFE_WriteToBuffer_4_Int32(value.Length);
				for (int k = 0; k < num; k++)
				{
					this.buffer[bufferIndex++] = (byte)value[k];
				}
				return;
			}
			FlushToStream();
			Stream.WriteByte(0);
			ProperBitConverter.GetBytes(small_buffer, 0, value.Length);
			Stream.Write(small_buffer, 0, 4);
			using Buffer<byte> buffer2 = Buffer<byte>.Claim(value.Length);
			byte[] array2 = buffer2.Array;
			for (int l = 0; l < value.Length; l++)
			{
				array2[l] = (byte)value[l];
			}
			Stream.Write(array2, 0, value.Length);
		}

		public override void FlushToStream()
		{
			if (bufferIndex > 0)
			{
				Stream.Write(buffer, 0, bufferIndex);
				bufferIndex = 0;
			}
			base.FlushToStream();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void UNSAFE_WriteToBuffer_2_Char(char value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					*(char*)(ptr + bufferIndex) = value;
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 1;
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void UNSAFE_WriteToBuffer_2_Int16(short value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					*(short*)(ptr + bufferIndex) = value;
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 1;
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void UNSAFE_WriteToBuffer_2_UInt16(ushort value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					*(ushort*)(ptr + bufferIndex) = value;
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 1;
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void UNSAFE_WriteToBuffer_4_Int32(int value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					*(int*)(ptr + bufferIndex) = value;
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 3;
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void UNSAFE_WriteToBuffer_4_UInt32(uint value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					*(uint*)(ptr + bufferIndex) = value;
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 3;
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void UNSAFE_WriteToBuffer_4_Float32(float value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
					{
						*(float*)(ptr + bufferIndex) = value;
					}
					else
					{
						byte* ptr2 = (byte*)(&value);
						byte* ptr3 = ptr + bufferIndex;
						*(ptr3++) = *(ptr2++);
						*(ptr3++) = *(ptr2++);
						*(ptr3++) = *(ptr2++);
						*ptr3 = *ptr2;
					}
				}
				else
				{
					byte* ptr4 = ptr + bufferIndex;
					byte* ptr5 = (byte*)(&value) + 3;
					*(ptr4++) = *(ptr5--);
					*(ptr4++) = *(ptr5--);
					*(ptr4++) = *(ptr5--);
					*ptr4 = *ptr5;
				}
			}
			bufferIndex += 4;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe void UNSAFE_WriteToBuffer_8_Int64(long value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
					{
						*(long*)(ptr + bufferIndex) = value;
					}
					else
					{
						SixtyFourBitValueToByteUnion sixtyFourBitValueToByteUnion = default(SixtyFourBitValueToByteUnion);
						sixtyFourBitValueToByteUnion.longValue = value;
						buffer[bufferIndex] = sixtyFourBitValueToByteUnion.b0;
						buffer[bufferIndex + 1] = sixtyFourBitValueToByteUnion.b1;
						buffer[bufferIndex + 2] = sixtyFourBitValueToByteUnion.b2;
						buffer[bufferIndex + 3] = sixtyFourBitValueToByteUnion.b3;
						buffer[bufferIndex + 4] = sixtyFourBitValueToByteUnion.b4;
						buffer[bufferIndex + 5] = sixtyFourBitValueToByteUnion.b5;
						buffer[bufferIndex + 6] = sixtyFourBitValueToByteUnion.b6;
						buffer[bufferIndex + 7] = sixtyFourBitValueToByteUnion.b7;
					}
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 7;
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 8;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe void UNSAFE_WriteToBuffer_8_UInt64(ulong value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
					{
						*(ulong*)(ptr + bufferIndex) = value;
					}
					else
					{
						SixtyFourBitValueToByteUnion sixtyFourBitValueToByteUnion = default(SixtyFourBitValueToByteUnion);
						sixtyFourBitValueToByteUnion.ulongValue = value;
						buffer[bufferIndex] = sixtyFourBitValueToByteUnion.b0;
						buffer[bufferIndex + 1] = sixtyFourBitValueToByteUnion.b1;
						buffer[bufferIndex + 2] = sixtyFourBitValueToByteUnion.b2;
						buffer[bufferIndex + 3] = sixtyFourBitValueToByteUnion.b3;
						buffer[bufferIndex + 4] = sixtyFourBitValueToByteUnion.b4;
						buffer[bufferIndex + 5] = sixtyFourBitValueToByteUnion.b5;
						buffer[bufferIndex + 6] = sixtyFourBitValueToByteUnion.b6;
						buffer[bufferIndex + 7] = sixtyFourBitValueToByteUnion.b7;
					}
				}
				else
				{
					byte* ptr2 = ptr + bufferIndex;
					byte* ptr3 = (byte*)(&value) + 7;
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*(ptr2++) = *(ptr3--);
					*ptr2 = *ptr3;
				}
			}
			bufferIndex += 8;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe void UNSAFE_WriteToBuffer_8_Float64(double value)
		{
			fixed (byte* ptr = buffer)
			{
				if (BitConverter.IsLittleEndian)
				{
					if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites)
					{
						*(double*)(ptr + bufferIndex) = value;
					}
					else
					{
						SixtyFourBitValueToByteUnion sixtyFourBitValueToByteUnion = default(SixtyFourBitValueToByteUnion);
						sixtyFourBitValueToByteUnion.doubleValue = value;
						buffer[bufferIndex] = sixtyFourBitValueToByteUnion.b0;
						buffer[bufferIndex + 1] = sixtyFourBitValueToByteUnion.b1;

using System; using System.Collections; using System.Collections.Generic; using System.ComponentModel; using System.Configuration.Assemblies; 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.InteropServices; using System.Runtime.Serialization; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Threading; using JetBrains.Annotations; using OdinSerializer; using OdinSerializer.Utilities; using OdinSerializer.Utilities.Unsafe; using UnityEngine; using UnityEngine.Events; using UnityEngine.Serialization; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: RegisterFormatterLocator(typeof(ArrayFormatterLocator), -80)] [assembly: RegisterFormatterLocator(typeof(DelegateFormatterLocator), -50)] [assembly: RegisterFormatterLocator(typeof(GenericCollectionFormatterLocator), -100)] [assembly: RegisterFormatterLocator(typeof(ISerializableFormatterLocator), -110)] [assembly: RegisterFormatterLocator(typeof(SelfFormatterLocator), -60)] [assembly: RegisterFormatterLocator(typeof(TypeFormatterLocator), -70)] [assembly: RegisterFormatter(typeof(ArrayListFormatter), 0)] [assembly: RegisterFormatter(typeof(DateTimeFormatter), 0)] [assembly: RegisterFormatter(typeof(DateTimeOffsetFormatter), 0)] [assembly: RegisterFormatter(typeof(DerivedDictionaryFormatter<, , >), typeof(WeakDictionaryFormatter), -1)] [assembly: RegisterFormatter(typeof(DictionaryFormatter<, >), typeof(WeakDictionaryFormatter), 0)] [assembly: RegisterFormatter(typeof(DoubleLookupDictionaryFormatter<, , >), typeof(WeakDoubleLookupDictionaryFormatter), 0)] [assembly: RegisterFormatter(typeof(HashSetFormatter<>), typeof(WeakHashSetFormatter), 0)] [assembly: RegisterFormatter(typeof(KeyValuePairFormatter<, >), typeof(WeakKeyValuePairFormatter), 0)] [assembly: RegisterFormatter(typeof(ListFormatter<>), typeof(WeakListFormatter), 0)] [assembly: RegisterFormatter(typeof(MethodInfoFormatter<>), typeof(WeakMethodInfoFormatter), 0)] [assembly: RegisterFormatter(typeof(NullableFormatter<>), typeof(WeakNullableFormatter), 0)] [assembly: RegisterFormatter(typeof(QueueFormatter<, >), typeof(WeakQueueFormatter), 0)] [assembly: RegisterFormatter(typeof(StackFormatter<, >), typeof(WeakStackFormatter), 0)] [assembly: RegisterFormatter(typeof(TimeSpanFormatter), 0)] [assembly: RegisterFormatter(typeof(VersionFormatter), 0)] [assembly: RegisterDictionaryKeyPathProvider(typeof(Vector2DictionaryKeyPathProvider))] [assembly: RegisterDictionaryKeyPathProvider(typeof(Vector3DictionaryKeyPathProvider))] [assembly: RegisterDictionaryKeyPathProvider(typeof(Vector4DictionaryKeyPathProvider))] [assembly: RegisterFormatter(typeof(AnimationCurveFormatter), 0)] [assembly: RegisterFormatter(typeof(BoundsFormatter), 0)] [assembly: RegisterFormatter(typeof(Color32Formatter), 0)] [assembly: RegisterFormatterLocator(typeof(ColorBlockFormatterLocator), 0)] [assembly: RegisterFormatter(typeof(ColorFormatter), 0)] [assembly: RegisterFormatter(typeof(CoroutineFormatter), 0)] [assembly: RegisterFormatter(typeof(GradientAlphaKeyFormatter), 0)] [assembly: RegisterFormatter(typeof(GradientColorKeyFormatter), 0)] [assembly: RegisterFormatter(typeof(GradientFormatter), 0)] [assembly: RegisterFormatter(typeof(KeyframeFormatter), 0)] [assembly: RegisterFormatter(typeof(LayerMaskFormatter), 0)] [assembly: RegisterFormatter(typeof(QuaternionFormatter), 0)] [assembly: RegisterFormatter(typeof(RectFormatter), 0)] [assembly: RegisterFormatter(typeof(UnityEventFormatter<>), typeof(WeakUnityEventFormatter), 0)] [assembly: RegisterFormatter(typeof(Vector2Formatter), 0)] [assembly: RegisterFormatter(typeof(Vector3Formatter), 0)] [assembly: RegisterFormatter(typeof(Vector4Formatter), 0)] [assembly: RegisterFormatter(typeof(Vector2IntFormatter), 0)] [assembly: RegisterFormatter(typeof(Vector3IntFormatter), 0)] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("Sirenix IVS")] [assembly: AssemblyConfiguration("Release JIT")] [assembly: AssemblyCopyright("Copyright © 2018")] [assembly: AssemblyFileVersion("2024.2.2700.0")] [assembly: AssemblyInformationalVersion("2024.2.2700+17459f242d0a3ae7ad79384bb87781923c813f23")] [assembly: AssemblyProduct("OdinSerializer")] [assembly: AssemblyTitle("OdinSerializer")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Lordfirespeed/OdinSerializerThunderstore")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] namespace OdinSerializer { public class GlobalSerializationConfig { private static readonly GlobalSerializationConfig instance = new GlobalSerializationConfig(); public static GlobalSerializationConfig Instance => instance; public ILogger Logger => DefaultLoggers.UnityLogger; public DataFormat EditorSerializationFormat => DataFormat.Nodes; public DataFormat BuildSerializationFormat => DataFormat.Binary; public LoggingPolicy LoggingPolicy => LoggingPolicy.LogErrors; public ErrorHandlingPolicy ErrorHandlingPolicy => ErrorHandlingPolicy.Resilient; internal static bool HasInstanceLoaded => true; internal static void LoadInstanceIfAssetExists() { } } public abstract class BaseDataReader : BaseDataReaderWriter, IDataReader, IDisposable { private DeserializationContext context; private Stream stream; public int CurrentNodeId => base.CurrentNode.Id; public int CurrentNodeDepth => base.NodeDepth; public string CurrentNodeName => base.CurrentNode.Name; public virtual Stream Stream { get { return stream; } set { if (value == null) { throw new ArgumentNullException("value"); } if (!value.CanRead) { throw new ArgumentException("Cannot read from stream"); } stream = value; } } public DeserializationContext Context { get { if (context == null) { context = new DeserializationContext(); } return context; } set { context = value; } } protected BaseDataReader(Stream stream, DeserializationContext context) { this.context = context; if (stream != null) { Stream = stream; } } public abstract bool EnterNode(out Type type); public abstract bool ExitNode(); public abstract bool EnterArray(out long length); public abstract bool ExitArray(); public abstract bool ReadPrimitiveArray<T>(out T[] array) where T : struct; public abstract EntryType PeekEntry(out string name); public abstract bool ReadInternalReference(out int id); public abstract bool ReadExternalReference(out int index); public abstract bool ReadExternalReference(out Guid guid); public abstract bool ReadExternalReference(out string id); public abstract bool ReadChar(out char value); public abstract bool ReadString(out string value); public abstract bool ReadGuid(out Guid value); public abstract bool ReadSByte(out sbyte value); public abstract bool ReadInt16(out short value); public abstract bool ReadInt32(out int value); public abstract bool ReadInt64(out long value); public abstract bool ReadByte(out byte value); public abstract bool ReadUInt16(out ushort value); public abstract bool ReadUInt32(out uint value); public abstract bool ReadUInt64(out ulong value); public abstract bool ReadDecimal(out decimal value); public abstract bool ReadSingle(out float value); public abstract bool ReadDouble(out double value); public abstract bool ReadBoolean(out bool value); public abstract bool ReadNull(); public virtual void SkipEntry() { switch (PeekEntry()) { case EntryType.StartOfNode: { bool flag = true; EnterNode(out var type); try { if (type != null) { if (FormatterUtilities.IsPrimitiveType(type)) { Serializer serializer = Serializer.Get(type); object reference = serializer.ReadValueWeak(this); if (CurrentNodeId >= 0) { Context.RegisterInternalReference(CurrentNodeId, reference); } } else { IFormatter formatter = FormatterLocator.GetFormatter(type, Context.Config.SerializationPolicy); object reference2 = formatter.Deserialize(this); if (CurrentNodeId >= 0) { Context.RegisterInternalReference(CurrentNodeId, reference2); } } break; } while (true) { switch (PeekEntry()) { case EntryType.EndOfArray: ReadToNextEntry(); break; default: SkipEntry(); break; case EntryType.EndOfNode: case EntryType.EndOfStream: return; } } } catch (SerializationAbortException ex) { flag = false; throw ex; } finally { if (flag) { ExitNode(); } } } case EntryType.StartOfArray: ReadToNextEntry(); while (true) { switch (PeekEntry()) { case EntryType.EndOfArray: ReadToNextEntry(); return; case EntryType.EndOfNode: ReadToNextEntry(); break; default: SkipEntry(); break; case EntryType.EndOfStream: return; } } default: ReadToNextEntry(); break; case EntryType.EndOfNode: case EntryType.EndOfArray: break; } } public abstract void Dispose(); public virtual void PrepareNewSerializationSession() { ClearNodes(); } public abstract string GetDataDump(); protected abstract EntryType PeekEntry(); protected abstract EntryType ReadToNextEntry(); } public abstract class BaseDataReaderWriter { private NodeInfo[] nodes = new NodeInfo[32]; private int nodesLength; [Obsolete("Use the Binder member on the writer's SerializationContext/DeserializationContext instead.", false)] [EditorBrowsable(EditorBrowsableState.Never)] public TwoWaySerializationBinder Binder { get { if (this is IDataWriter) { return (this as IDataWriter).Context.Binder; } if (this is IDataReader) { return (this as IDataReader).Context.Binder; } return TwoWaySerializationBinder.Default; } set { if (this is IDataWriter) { (this as IDataWriter).Context.Binder = value; } else if (this is IDataReader) { (this as IDataReader).Context.Binder = value; } } } public bool IsInArrayNode { get { if (nodesLength != 0) { return nodes[nodesLength - 1].IsArray; } return false; } } protected int NodeDepth => nodesLength; protected NodeInfo[] NodesArray => nodes; protected NodeInfo CurrentNode { get { if (nodesLength != 0) { return nodes[nodesLength - 1]; } return NodeInfo.Empty; } } protected void PushNode(NodeInfo node) { if (nodesLength == nodes.Length) { ExpandNodes(); } nodes[nodesLength] = node; nodesLength++; } protected void PushNode(string name, int id, Type type) { if (nodesLength == nodes.Length) { ExpandNodes(); } nodes[nodesLength] = new NodeInfo(name, id, type, isArray: false); nodesLength++; } protected void PushArray() { if (nodesLength == nodes.Length) { ExpandNodes(); } if (nodesLength == 0 || nodes[nodesLength - 1].IsArray) { nodes[nodesLength] = new NodeInfo(null, -1, null, isArray: true); } else { NodeInfo nodeInfo = nodes[nodesLength - 1]; nodes[nodesLength] = new NodeInfo(nodeInfo.Name, nodeInfo.Id, nodeInfo.Type, isArray: true); } nodesLength++; } private void ExpandNodes() { NodeInfo[] array = new NodeInfo[nodes.Length * 2]; NodeInfo[] array2 = nodes; for (int i = 0; i < array2.Length; i++) { array[i] = array2[i]; } nodes = array; } protected void PopNode(string name) { if (nodesLength == 0) { throw new InvalidOperationException("There are no nodes to pop."); } nodesLength--; } protected void PopArray() { if (nodesLength == 0) { throw new InvalidOperationException("There are no nodes to pop."); } if (!nodes[nodesLength - 1].IsArray) { throw new InvalidOperationException("Was not in array when exiting array."); } nodesLength--; } protected void ClearNodes() { nodesLength = 0; } } public abstract class BaseDataWriter : BaseDataReaderWriter, IDataWriter, IDisposable { private SerializationContext context; private Stream stream; public virtual Stream Stream { get { return stream; } set { if (value == null) { throw new ArgumentNullException("value"); } if (!value.CanWrite) { throw new ArgumentException("Cannot write to stream"); } stream = value; } } public SerializationContext Context { get { if (context == null) { context = new SerializationContext(); } return context; } set { context = value; } } protected BaseDataWriter(Stream stream, SerializationContext context) { this.context = context; if (stream != null) { Stream = stream; } } public virtual void FlushToStream() { Stream.Flush(); } public abstract void BeginReferenceNode(string name, Type type, int id); public abstract void BeginStructNode(string name, Type type); public abstract void EndNode(string name); public abstract void BeginArrayNode(long length); public abstract void EndArrayNode(); public abstract void WritePrimitiveArray<T>(T[] array) where T : struct; public abstract void WriteNull(string name); public abstract void WriteInternalReference(string name, int id); public abstract void WriteExternalReference(string name, int index); public abstract void WriteExternalReference(string name, Guid guid); public abstract void WriteExternalReference(string name, string id); public abstract void WriteChar(string name, char value); public abstract void WriteString(string name, string value); public abstract void WriteGuid(string name, Guid value); public abstract void WriteSByte(string name, sbyte value); public abstract void WriteInt16(string name, short value); public abstract void WriteInt32(string name, int value); public abstract void WriteInt64(string name, long value); public abstract void WriteByte(string name, byte value); public abstract void WriteUInt16(string name, ushort value); public abstract void WriteUInt32(string name, uint value); public abstract void WriteUInt64(string name, ulong value); public abstract void WriteDecimal(string name, decimal value); public abstract void WriteSingle(string name, float value); public abstract void WriteDouble(string name, double value); public abstract void WriteBoolean(string name, bool value); public abstract void Dispose(); public virtual void PrepareNewSerializationSession() { ClearNodes(); } public abstract string GetDataDump(); } public class BinaryDataReader : BaseDataReader { private struct Struct256Bit { public decimal d1; public decimal d2; } private static readonly Dictionary<Type, Delegate> PrimitiveFromByteMethods = new Dictionary<Type, Delegate> { { typeof(char), (Func<byte[], int, char>)((byte[] b, int i) => (char)ProperBitConverter.ToUInt16(b, i)) }, { typeof(byte), (Func<byte[], int, byte>)((byte[] b, int i) => b[i]) }, { typeof(sbyte), (Func<byte[], int, sbyte>)((byte[] b, int i) => (sbyte)b[i]) }, { typeof(bool), (Func<byte[], int, bool>)((byte[] b, int i) => b[i] != 0) }, { typeof(short), new Func<byte[], int, short>(ProperBitConverter.ToInt16) }, { typeof(int), new Func<byte[], int, int>(ProperBitConverter.ToInt32) }, { typeof(long), new Func<byte[], int, long>(ProperBitConverter.ToInt64) }, { typeof(ushort), new Func<byte[], int, ushort>(ProperBitConverter.ToUInt16) }, { typeof(uint), new Func<byte[], int, uint>(ProperBitConverter.ToUInt32) }, { typeof(ulong), new Func<byte[], int, ulong>(ProperBitConverter.ToUInt64) }, { typeof(decimal), new Func<byte[], int, decimal>(ProperBitConverter.ToDecimal) }, { typeof(float), new Func<byte[], int, float>(ProperBitConverter.ToSingle) }, { typeof(double), new Func<byte[], int, double>(ProperBitConverter.ToDouble) }, { typeof(Guid), new Func<byte[], int, Guid>(ProperBitConverter.ToGuid) } }; private byte[] internalBufferBackup; private byte[] buffer = new byte[102400]; private int bufferIndex; private int bufferEnd; private EntryType? peekedEntryType; private BinaryEntryType peekedBinaryEntryType; private string peekedEntryName; private Dictionary<int, Type> types = new Dictionary<int, Type>(16); public BinaryDataReader() : base(null, null) { internalBufferBackup = buffer; } public BinaryDataReader(Stream stream, DeserializationContext context) : base(stream, context) { internalBufferBackup = buffer; } public override void Dispose() { } public override EntryType PeekEntry(out string name) { if (peekedEntryType.HasValue) { name = peekedEntryName; return peekedEntryType.Value; } peekedBinaryEntryType = (BinaryEntryType)(HasBufferData(1) ? buffer[bufferIndex++] : 49); switch (peekedBinaryEntryType) { case BinaryEntryType.EndOfStream: name = null; peekedEntryName = null; peekedEntryType = EntryType.EndOfStream; break; case BinaryEntryType.NamedStartOfReferenceNode: case BinaryEntryType.NamedStartOfStructNode: name = ReadStringValue(); peekedEntryType = EntryType.StartOfNode; break; case BinaryEntryType.UnnamedStartOfReferenceNode: case BinaryEntryType.UnnamedStartOfStructNode: name = null; peekedEntryType = EntryType.StartOfNode; break; case BinaryEntryType.EndOfNode: name = null; peekedEntryType = EntryType.EndOfNode; break; case BinaryEntryType.StartOfArray: name = null; peekedEntryType = EntryType.StartOfArray; break; case BinaryEntryType.EndOfArray: name = null; peekedEntryType = EntryType.EndOfArray; break; case BinaryEntryType.PrimitiveArray: name = null; peekedEntryType = EntryType.PrimitiveArray; break; case BinaryEntryType.NamedInternalReference: name = ReadStringValue(); peekedEntryType = EntryType.InternalReference; break; case BinaryEntryType.UnnamedInternalReference: name = null; peekedEntryType = EntryType.InternalReference; break; case BinaryEntryType.NamedExternalReferenceByIndex: name = ReadStringValue(); peekedEntryType = EntryType.ExternalReferenceByIndex; break; case BinaryEntryType.UnnamedExternalReferenceByIndex: name = null; peekedEntryType = EntryType.ExternalReferenceByIndex; break; case BinaryEntryType.NamedExternalReferenceByGuid: name = ReadStringValue(); peekedEntryType = EntryType.ExternalReferenceByGuid; break; case BinaryEntryType.UnnamedExternalReferenceByGuid: name = null; peekedEntryType = EntryType.ExternalReferenceByGuid; break; case BinaryEntryType.NamedExternalReferenceByString: name = ReadStringValue(); peekedEntryType = EntryType.ExternalReferenceByString; break; case BinaryEntryType.UnnamedExternalReferenceByString: name = null; peekedEntryType = EntryType.ExternalReferenceByString; break; case BinaryEntryType.NamedSByte: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedSByte: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedByte: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedByte: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedShort: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedShort: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedUShort: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedUShort: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedInt: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedInt: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedUInt: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedUInt: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedLong: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedLong: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedULong: name = ReadStringValue(); peekedEntryType = EntryType.Integer; break; case BinaryEntryType.UnnamedULong: name = null; peekedEntryType = EntryType.Integer; break; case BinaryEntryType.NamedFloat: name = ReadStringValue(); peekedEntryType = EntryType.FloatingPoint; break; case BinaryEntryType.UnnamedFloat: name = null; peekedEntryType = EntryType.FloatingPoint; break; case BinaryEntryType.NamedDouble: name = ReadStringValue(); peekedEntryType = EntryType.FloatingPoint; break; case BinaryEntryType.UnnamedDouble: name = null; peekedEntryType = EntryType.FloatingPoint; break; case BinaryEntryType.NamedDecimal: name = ReadStringValue(); peekedEntryType = EntryType.FloatingPoint; break; case BinaryEntryType.UnnamedDecimal: name = null; peekedEntryType = EntryType.FloatingPoint; break; case BinaryEntryType.NamedChar: name = ReadStringValue(); peekedEntryType = EntryType.String; break; case BinaryEntryType.UnnamedChar: name = null; peekedEntryType = EntryType.String; break; case BinaryEntryType.NamedString: name = ReadStringValue(); peekedEntryType = EntryType.String; break; case BinaryEntryType.UnnamedString: name = null; peekedEntryType = EntryType.String; break; case BinaryEntryType.NamedGuid: name = ReadStringValue(); peekedEntryType = EntryType.Guid; break; case BinaryEntryType.UnnamedGuid: name = null; peekedEntryType = EntryType.Guid; break; case BinaryEntryType.NamedBoolean: name = ReadStringValue(); peekedEntryType = EntryType.Boolean; break; case BinaryEntryType.UnnamedBoolean: name = null; peekedEntryType = EntryType.Boolean; break; case BinaryEntryType.NamedNull: name = ReadStringValue(); peekedEntryType = EntryType.Null; break; case BinaryEntryType.UnnamedNull: name = null; peekedEntryType = EntryType.Null; break; case BinaryEntryType.TypeName: case BinaryEntryType.TypeID: peekedBinaryEntryType = BinaryEntryType.Invalid; peekedEntryType = EntryType.Invalid; throw new InvalidOperationException("Invalid binary data stream: BinaryEntryType.TypeName and BinaryEntryType.TypeID must never be peeked by the binary reader."); default: { name = null; peekedBinaryEntryType = BinaryEntryType.Invalid; peekedEntryType = EntryType.Invalid; byte b = (byte)peekedBinaryEntryType; throw new InvalidOperationException("Invalid binary data stream: could not parse peeked BinaryEntryType byte '" + b + "' into a known entry type."); } } peekedEntryName = name; return peekedEntryType.Value; } public override bool EnterArray(out long length) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedEntryType == EntryType.StartOfArray) { PushArray(); MarkEntryContentConsumed(); if (UNSAFE_Read_8_Int64(out length)) { if (length < 0) { length = 0L; base.Context.Config.DebugContext.LogError("Invalid array length: " + length + "."); return false; } return true; } return false; } SkipEntry(); length = 0L; return false; } public override bool EnterNode(out Type type) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedStartOfReferenceNode || peekedBinaryEntryType == BinaryEntryType.UnnamedStartOfReferenceNode) { MarkEntryContentConsumed(); type = ReadTypeEntry(); if (!UNSAFE_Read_4_Int32(out var value)) { type = null; return false; } PushNode(peekedEntryName, value, type); return true; } if (peekedBinaryEntryType == BinaryEntryType.NamedStartOfStructNode || peekedBinaryEntryType == BinaryEntryType.UnnamedStartOfStructNode) { type = ReadTypeEntry(); PushNode(peekedEntryName, -1, type); MarkEntryContentConsumed(); return true; } SkipEntry(); type = null; return false; } public override bool ExitArray() { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } while (peekedBinaryEntryType != BinaryEntryType.EndOfArray && peekedBinaryEntryType != BinaryEntryType.EndOfStream) { if (peekedEntryType == EntryType.EndOfNode) { base.Context.Config.DebugContext.LogError("Data layout mismatch; skipping past node boundary when exiting array."); MarkEntryContentConsumed(); } SkipEntry(); } if (peekedBinaryEntryType == BinaryEntryType.EndOfArray) { MarkEntryContentConsumed(); PopArray(); return true; } return false; } public override bool ExitNode() { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } while (peekedBinaryEntryType != BinaryEntryType.EndOfNode && peekedBinaryEntryType != BinaryEntryType.EndOfStream) { if (peekedEntryType == EntryType.EndOfArray) { base.Context.Config.DebugContext.LogError("Data layout mismatch; skipping past array boundary when exiting node."); MarkEntryContentConsumed(); } SkipEntry(); } if (peekedBinaryEntryType == BinaryEntryType.EndOfNode) { MarkEntryContentConsumed(); PopNode(base.CurrentNodeName); return true; } return false; } public unsafe override bool ReadPrimitiveArray<T>(out T[] array) { if (!FormatterUtilities.IsPrimitiveArrayType(typeof(T))) { throw new ArgumentException("Type " + typeof(T).Name + " is not a valid primitive array type."); } if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedEntryType == EntryType.PrimitiveArray) { MarkEntryContentConsumed(); if (!UNSAFE_Read_4_Int32(out var value) || !UNSAFE_Read_4_Int32(out var value2)) { array = null; return false; } int num = value * value2; if (!HasBufferData(num)) { bufferIndex = bufferEnd; array = null; return false; } if (typeof(T) == typeof(byte)) { byte[] array2 = new byte[num]; Buffer.BlockCopy(buffer, bufferIndex, array2, 0, num); array = (T[])(object)array2; bufferIndex += num; return true; } array = new T[value]; if (BitConverter.IsLittleEndian) { GCHandle gCHandle = GCHandle.Alloc(array, GCHandleType.Pinned); try { fixed (byte* ptr = buffer) { void* from = ptr + bufferIndex; void* to = gCHandle.AddrOfPinnedObject().ToPointer(); UnsafeUtilities.MemoryCopy(from, to, num); } } finally { gCHandle.Free(); } } else { Func<byte[], int, T> func = (Func<byte[], int, T>)PrimitiveFromByteMethods[typeof(T)]; for (int i = 0; i < value; i++) { array[i] = func(buffer, bufferIndex + i * value2); } } bufferIndex += num; return true; } SkipEntry(); array = null; return false; } public override bool ReadBoolean(out bool value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedEntryType == EntryType.Boolean) { MarkEntryContentConsumed(); if (HasBufferData(1)) { value = buffer[bufferIndex++] == 1; return true; } value = false; return false; } SkipEntry(); value = false; return false; } public override bool ReadSByte(out sbyte value) { if (ReadInt64(out var value2)) { try { value = checked((sbyte)value2); } catch (OverflowException) { value = 0; } return true; } value = 0; return false; } public override bool ReadByte(out byte value) { if (ReadUInt64(out var value2)) { try { value = checked((byte)value2); } catch (OverflowException) { value = 0; } return true; } value = 0; return false; } public override bool ReadInt16(out short value) { if (ReadInt64(out var value2)) { try { value = checked((short)value2); } catch (OverflowException) { value = 0; } return true; } value = 0; return false; } public override bool ReadUInt16(out ushort value) { if (ReadUInt64(out var value2)) { try { value = checked((ushort)value2); } catch (OverflowException) { value = 0; } return true; } value = 0; return false; } public override bool ReadInt32(out int value) { if (ReadInt64(out var value2)) { try { value = checked((int)value2); } catch (OverflowException) { value = 0; } return true; } value = 0; return false; } public override bool ReadUInt32(out uint value) { if (ReadUInt64(out var value2)) { try { value = checked((uint)value2); } catch (OverflowException) { value = 0u; } return true; } value = 0u; return false; } public override bool ReadInt64(out long value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedEntryType == EntryType.Integer) { try { switch (peekedBinaryEntryType) { case BinaryEntryType.NamedSByte: case BinaryEntryType.UnnamedSByte: { if (!UNSAFE_Read_1_SByte(out var value5)) { value = 0L; return false; } value = value5; break; } case BinaryEntryType.NamedByte: case BinaryEntryType.UnnamedByte: { if (!UNSAFE_Read_1_Byte(out var value6)) { value = 0L; return false; } value = value6; break; } case BinaryEntryType.NamedShort: case BinaryEntryType.UnnamedShort: { if (!UNSAFE_Read_2_Int16(out var value7)) { value = 0L; return false; } value = value7; break; } case BinaryEntryType.NamedUShort: case BinaryEntryType.UnnamedUShort: { if (!UNSAFE_Read_2_UInt16(out var value3)) { value = 0L; return false; } value = value3; break; } case BinaryEntryType.NamedInt: case BinaryEntryType.UnnamedInt: { if (!UNSAFE_Read_4_Int32(out var value4)) { value = 0L; return false; } value = value4; break; } case BinaryEntryType.NamedUInt: case BinaryEntryType.UnnamedUInt: { if (!UNSAFE_Read_4_UInt32(out var value8)) { value = 0L; return false; } value = value8; break; } case BinaryEntryType.NamedLong: case BinaryEntryType.UnnamedLong: if (!UNSAFE_Read_8_Int64(out value)) { return false; } break; case BinaryEntryType.NamedULong: case BinaryEntryType.UnnamedULong: { if (!UNSAFE_Read_8_UInt64(out var value2)) { value = 0L; return false; } if (value2 > long.MaxValue) { value = 0L; return false; } value = (long)value2; break; } default: throw new InvalidOperationException(); } return true; } finally { MarkEntryContentConsumed(); } } SkipEntry(); value = 0L; return false; } public override bool ReadUInt64(out ulong value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedEntryType == EntryType.Integer) { try { switch (peekedBinaryEntryType) { case BinaryEntryType.NamedSByte: case BinaryEntryType.UnnamedSByte: case BinaryEntryType.NamedByte: case BinaryEntryType.UnnamedByte: { if (!UNSAFE_Read_1_Byte(out var value7)) { value = 0uL; return false; } value = value7; break; } case BinaryEntryType.NamedShort: case BinaryEntryType.UnnamedShort: { if (!UNSAFE_Read_2_Int16(out var value4)) { value = 0uL; return false; } if (value4 < 0) { value = 0uL; return false; } value = (ulong)value4; break; } case BinaryEntryType.NamedUShort: case BinaryEntryType.UnnamedUShort: { if (!UNSAFE_Read_2_UInt16(out var value6)) { value = 0uL; return false; } value = value6; break; } case BinaryEntryType.NamedInt: case BinaryEntryType.UnnamedInt: { if (!UNSAFE_Read_4_Int32(out var value5)) { value = 0uL; return false; } if (value5 < 0) { value = 0uL; return false; } value = (ulong)value5; break; } case BinaryEntryType.NamedUInt: case BinaryEntryType.UnnamedUInt: { if (!UNSAFE_Read_4_UInt32(out var value2)) { value = 0uL; return false; } value = value2; break; } case BinaryEntryType.NamedLong: case BinaryEntryType.UnnamedLong: { if (!UNSAFE_Read_8_Int64(out var value3)) { value = 0uL; return false; } if (value3 < 0) { value = 0uL; return false; } value = (ulong)value3; break; } case BinaryEntryType.NamedULong: case BinaryEntryType.UnnamedULong: if (!UNSAFE_Read_8_UInt64(out value)) { return false; } break; default: throw new InvalidOperationException(); } return true; } finally { MarkEntryContentConsumed(); } } SkipEntry(); value = 0uL; return false; } public override bool ReadChar(out char value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedChar || peekedBinaryEntryType == BinaryEntryType.UnnamedChar) { MarkEntryContentConsumed(); return UNSAFE_Read_2_Char(out value); } if (peekedBinaryEntryType == BinaryEntryType.NamedString || peekedBinaryEntryType == BinaryEntryType.UnnamedString) { MarkEntryContentConsumed(); string text = ReadStringValue(); if (text == null || text.Length == 0) { value = '\0'; return false; } value = text[0]; return true; } SkipEntry(); value = '\0'; return false; } public override bool ReadSingle(out float value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedFloat || peekedBinaryEntryType == BinaryEntryType.UnnamedFloat) { MarkEntryContentConsumed(); return UNSAFE_Read_4_Float32(out value); } if (peekedBinaryEntryType == BinaryEntryType.NamedDouble || peekedBinaryEntryType == BinaryEntryType.UnnamedDouble) { MarkEntryContentConsumed(); if (!UNSAFE_Read_8_Float64(out var value2)) { value = 0f; return false; } try { value = (float)value2; } catch (OverflowException) { value = 0f; } return true; } if (peekedBinaryEntryType == BinaryEntryType.NamedDecimal || peekedBinaryEntryType == BinaryEntryType.UnnamedDecimal) { MarkEntryContentConsumed(); if (!UNSAFE_Read_16_Decimal(out var value3)) { value = 0f; return false; } try { value = (float)value3; } catch (OverflowException) { value = 0f; } return true; } if (peekedEntryType == EntryType.Integer) { if (!ReadInt64(out var value4)) { value = 0f; return false; } try { value = value4; } catch (OverflowException) { value = 0f; } return true; } SkipEntry(); value = 0f; return false; } public override bool ReadDouble(out double value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedDouble || peekedBinaryEntryType == BinaryEntryType.UnnamedDouble) { MarkEntryContentConsumed(); return UNSAFE_Read_8_Float64(out value); } if (peekedBinaryEntryType == BinaryEntryType.NamedFloat || peekedBinaryEntryType == BinaryEntryType.UnnamedFloat) { MarkEntryContentConsumed(); if (!UNSAFE_Read_4_Float32(out var value2)) { value = 0.0; return false; } value = value2; return true; } if (peekedBinaryEntryType == BinaryEntryType.NamedDecimal || peekedBinaryEntryType == BinaryEntryType.UnnamedDecimal) { MarkEntryContentConsumed(); if (!UNSAFE_Read_16_Decimal(out var value3)) { value = 0.0; return false; } try { value = (double)value3; } catch (OverflowException) { value = 0.0; } return true; } if (peekedEntryType == EntryType.Integer) { if (!ReadInt64(out var value4)) { value = 0.0; return false; } try { value = value4; } catch (OverflowException) { value = 0.0; } return true; } SkipEntry(); value = 0.0; return false; } public override bool ReadDecimal(out decimal value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedDecimal || peekedBinaryEntryType == BinaryEntryType.UnnamedDecimal) { MarkEntryContentConsumed(); return UNSAFE_Read_16_Decimal(out value); } if (peekedBinaryEntryType == BinaryEntryType.NamedDouble || peekedBinaryEntryType == BinaryEntryType.UnnamedDouble) { MarkEntryContentConsumed(); if (!UNSAFE_Read_8_Float64(out var value2)) { value = default(decimal); return false; } try { value = (decimal)value2; } catch (OverflowException) { value = default(decimal); } return true; } if (peekedBinaryEntryType == BinaryEntryType.NamedFloat || peekedBinaryEntryType == BinaryEntryType.UnnamedFloat) { MarkEntryContentConsumed(); if (!UNSAFE_Read_4_Float32(out var value3)) { value = default(decimal); return false; } try { value = (decimal)value3; } catch (OverflowException) { value = default(decimal); } return true; } if (peekedEntryType == EntryType.Integer) { if (!ReadInt64(out var value4)) { value = default(decimal); return false; } try { value = value4; } catch (OverflowException) { value = default(decimal); } return true; } SkipEntry(); value = default(decimal); return false; } public override bool ReadExternalReference(out Guid guid) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedExternalReferenceByGuid || peekedBinaryEntryType == BinaryEntryType.UnnamedExternalReferenceByGuid) { MarkEntryContentConsumed(); return UNSAFE_Read_16_Guid(out guid); } SkipEntry(); guid = default(Guid); return false; } public override bool ReadGuid(out Guid value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedGuid || peekedBinaryEntryType == BinaryEntryType.UnnamedGuid) { MarkEntryContentConsumed(); return UNSAFE_Read_16_Guid(out value); } SkipEntry(); value = default(Guid); return false; } public override bool ReadExternalReference(out int index) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedExternalReferenceByIndex || peekedBinaryEntryType == BinaryEntryType.UnnamedExternalReferenceByIndex) { MarkEntryContentConsumed(); return UNSAFE_Read_4_Int32(out index); } SkipEntry(); index = -1; return false; } public override bool ReadExternalReference(out string id) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedExternalReferenceByString || peekedBinaryEntryType == BinaryEntryType.UnnamedExternalReferenceByString) { id = ReadStringValue(); MarkEntryContentConsumed(); return id != null; } SkipEntry(); id = null; return false; } public override bool ReadNull() { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedNull || peekedBinaryEntryType == BinaryEntryType.UnnamedNull) { MarkEntryContentConsumed(); return true; } SkipEntry(); return false; } public override bool ReadInternalReference(out int id) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedInternalReference || peekedBinaryEntryType == BinaryEntryType.UnnamedInternalReference) { MarkEntryContentConsumed(); return UNSAFE_Read_4_Int32(out id); } SkipEntry(); id = -1; return false; } public override bool ReadString(out string value) { if (!peekedEntryType.HasValue) { PeekEntry(out var _); } if (peekedBinaryEntryType == BinaryEntryType.NamedString || peekedBinaryEntryType == BinaryEntryType.UnnamedString) { value = ReadStringValue(); MarkEntryContentConsumed(); return value != null; } SkipEntry(); value = null; return false; } public override void PrepareNewSerializationSession() { base.PrepareNewSerializationSession(); peekedEntryType = null; peekedEntryName = null; peekedBinaryEntryType = BinaryEntryType.Invalid; types.Clear(); bufferIndex = 0; bufferEnd = 0; buffer = internalBufferBackup; } public unsafe override string GetDataDump() { byte[] array; if (bufferEnd == buffer.Length) { array = buffer; } else { array = new byte[bufferEnd]; fixed (byte* ptr = buffer) { void* from = ptr; fixed (byte* ptr2 = array) { void* to = ptr2; UnsafeUtilities.MemoryCopy(from, to, array.Length); } } } return "Binary hex dump: " + ProperBitConverter.BytesToHexString(array); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe string ReadStringValue() { if (!UNSAFE_Read_1_Byte(out var value)) { return null; } if (!UNSAFE_Read_4_Int32(out var value2)) { return null; } string text = new string(' ', value2); if (value == 0) { fixed (byte* ptr = buffer) { fixed (char* ptr3 = text) { byte* ptr2 = ptr + bufferIndex; byte* ptr4 = (byte*)ptr3; if (BitConverter.IsLittleEndian) { for (int i = 0; i < value2; i++) { *(ptr4++) = *(ptr2++); ptr4++; } } else { for (int j = 0; j < value2; j++) { ptr4++; *(ptr4++) = *(ptr2++); } } } } bufferIndex += value2; return text; } int num = value2 * 2; fixed (byte* ptr5 = buffer) { fixed (char* ptr7 = text) { if (BitConverter.IsLittleEndian) { Struct256Bit* ptr6 = (Struct256Bit*)(ptr5 + bufferIndex); Struct256Bit* ptr8 = (Struct256Bit*)ptr7; byte* ptr9 = (byte*)ptr7 + num; while (ptr8 + 1 < ptr9) { *(ptr8++) = *(ptr6++); } byte* ptr10 = (byte*)ptr6; byte* ptr11 = (byte*)ptr8; while (ptr11 < ptr9) { *(ptr11++) = *(ptr10++); } } else { byte* ptr12 = ptr5 + bufferIndex; byte* ptr13 = (byte*)ptr7; for (int k = 0; k < value2; k++) { *ptr13 = ptr12[1]; ptr13[1] = *ptr12; ptr12 += 2; ptr13 += 2; } } } } bufferIndex += num; return text; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private void SkipStringValue() { if (UNSAFE_Read_1_Byte(out var value) && UNSAFE_Read_4_Int32(out var value2)) { if (value != 0) { value2 *= 2; } if (HasBufferData(value2)) { bufferIndex += value2; } else { bufferIndex = bufferEnd; } } } private void SkipPeekedEntryContent() { if (!peekedEntryType.HasValue) { return; } try { switch (peekedBinaryEntryType) { case BinaryEntryType.NamedStartOfReferenceNode: case BinaryEntryType.UnnamedStartOfReferenceNode: ReadTypeEntry(); if (SkipBuffer(4)) { } break; case BinaryEntryType.NamedStartOfStructNode: case BinaryEntryType.UnnamedStartOfStructNode: ReadTypeEntry(); break; case BinaryEntryType.StartOfArray: SkipBuffer(8); break; case BinaryEntryType.PrimitiveArray: { if (UNSAFE_Read_4_Int32(out var value) && UNSAFE_Read_4_Int32(out var value2)) { SkipBuffer(value * value2); } break; } case BinaryEntryType.NamedSByte: case BinaryEntryType.UnnamedSByte: case BinaryEntryType.NamedByte: case BinaryEntryType.UnnamedByte: case BinaryEntryType.NamedBoolean: case BinaryEntryType.UnnamedBoolean: SkipBuffer(1); break; case BinaryEntryType.NamedShort: case BinaryEntryType.UnnamedShort: case BinaryEntryType.NamedUShort: case BinaryEntryType.UnnamedUShort: case BinaryEntryType.NamedChar: case BinaryEntryType.UnnamedChar: SkipBuffer(2); break; case BinaryEntryType.NamedInternalReference: case BinaryEntryType.UnnamedInternalReference: case BinaryEntryType.NamedExternalReferenceByIndex: case BinaryEntryType.UnnamedExternalReferenceByIndex: case BinaryEntryType.NamedInt: case BinaryEntryType.UnnamedInt: case BinaryEntryType.NamedUInt: case BinaryEntryType.UnnamedUInt: case BinaryEntryType.NamedFloat: case BinaryEntryType.UnnamedFloat: SkipBuffer(4); break; case BinaryEntryType.NamedLong: case BinaryEntryType.UnnamedLong: case BinaryEntryType.NamedULong: case BinaryEntryType.UnnamedULong: case BinaryEntryType.NamedDouble: case BinaryEntryType.UnnamedDouble: SkipBuffer(8); break; case BinaryEntryType.NamedExternalReferenceByGuid: case BinaryEntryType.UnnamedExternalReferenceByGuid: case BinaryEntryType.NamedDecimal: case BinaryEntryType.UnnamedDecimal: case BinaryEntryType.NamedGuid: case BinaryEntryType.UnnamedGuid: SkipBuffer(8); break; case BinaryEntryType.NamedString: case BinaryEntryType.UnnamedString: case BinaryEntryType.NamedExternalReferenceByString: case BinaryEntryType.UnnamedExternalReferenceByString: SkipStringValue(); break; case BinaryEntryType.TypeName: base.Context.Config.DebugContext.LogError("Parsing error in binary data reader: should not be able to peek a TypeName entry."); SkipBuffer(4); ReadStringValue(); break; case BinaryEntryType.TypeID: base.Context.Config.DebugContext.LogError("Parsing error in binary data reader: should not be able to peek a TypeID entry."); SkipBuffer(4); break; case BinaryEntryType.Invalid: case BinaryEntryType.EndOfNode: case BinaryEntryType.EndOfArray: case BinaryEntryType.NamedNull: case BinaryEntryType.UnnamedNull: case BinaryEntryType.EndOfStream: break; } } finally { MarkEntryContentConsumed(); } } [MethodImpl(MethodImplOptions.AggressiveInlining)] private bool SkipBuffer(int amount) { int num = bufferIndex + amount; if (num > bufferEnd) { bufferIndex = bufferEnd; return false; } bufferIndex = num; return true; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private Type ReadTypeEntry() { if (!HasBufferData(1)) { return null; } BinaryEntryType binaryEntryType = (BinaryEntryType)buffer[bufferIndex++]; int value2; Type value; switch (binaryEntryType) { case BinaryEntryType.TypeID: if (!UNSAFE_Read_4_Int32(out value2)) { return null; } if (!types.TryGetValue(value2, out value)) { base.Context.Config.DebugContext.LogError("Missing type ID during deserialization: " + value2 + " at node " + base.CurrentNodeName + " and depth " + base.CurrentNodeDepth + " and id " + base.CurrentNodeId); } break; case BinaryEntryType.TypeName: { if (!UNSAFE_Read_4_Int32(out value2)) { return null; } string text = ReadStringValue(); value = ((text == null) ? null : base.Context.Binder.BindToType(text, base.Context.Config.DebugContext)); types.Add(value2, value); break; } case BinaryEntryType.UnnamedNull: value = null; break; default: value = null; base.Context.Config.DebugContext.LogError("Expected TypeName, TypeID or UnnamedNull entry flag for reading type data, but instead got the entry flag: " + binaryEntryType.ToString() + "."); break; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private void MarkEntryContentConsumed() { peekedEntryType = null; peekedEntryName = null; peekedBinaryEntryType = BinaryEntryType.Invalid; } protected override EntryType PeekEntry() { string name; return PeekEntry(out name); } protected override EntryType ReadToNextEntry() { SkipPeekedEntryContent(); string name; return PeekEntry(out name); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private bool UNSAFE_Read_1_Byte(out byte value) { if (HasBufferData(1)) { value = buffer[bufferIndex++]; return true; } value = 0; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private bool UNSAFE_Read_1_SByte(out sbyte value) { if (HasBufferData(1)) { value = (sbyte)buffer[bufferIndex++]; return true; } value = 0; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_2_Int16(out short value) { if (HasBufferData(2)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { value = *(short*)(ptr + bufferIndex); } else { short num = 0; byte* ptr2 = (byte*)(&num) + 1; byte* ptr3 = ptr + bufferIndex; *(ptr2--) = *(ptr3++); *ptr2 = *ptr3; value = num; } } bufferIndex += 2; return true; } bufferIndex = bufferEnd; value = 0; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_2_UInt16(out ushort value) { if (HasBufferData(2)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { value = *(ushort*)(ptr + bufferIndex); } else { ushort num = 0; byte* ptr2 = (byte*)(&num) + 1; byte* ptr3 = ptr + bufferIndex; *(ptr2--) = *(ptr3++); *ptr2 = *ptr3; value = num; } } bufferIndex += 2; return true; } bufferIndex = bufferEnd; value = 0; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_2_Char(out char value) { if (HasBufferData(2)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { value = *(char*)(ptr + bufferIndex); } else { char c = '\0'; byte* ptr2 = (byte*)(&c) + 1; byte* ptr3 = ptr + bufferIndex; *(ptr2--) = *(ptr3++); *ptr2 = *ptr3; value = c; } } bufferIndex += 2; return true; } bufferIndex = bufferEnd; value = '\0'; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_4_Int32(out int value) { if (HasBufferData(4)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { value = *(int*)(ptr + bufferIndex); } else { int num = 0; byte* ptr2 = (byte*)(&num) + 3; byte* ptr3 = ptr + bufferIndex; *(ptr2--) = *(ptr3++); *(ptr2--) = *(ptr3++); *(ptr2--) = *(ptr3++); *ptr2 = *ptr3; value = num; } } bufferIndex += 4; return true; } bufferIndex = bufferEnd; value = 0; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_4_UInt32(out uint value) { if (HasBufferData(4)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { value = *(uint*)(ptr + bufferIndex); } else { uint num = 0u; byte* ptr2 = (byte*)(&num) + 3; byte* ptr3 = ptr + bufferIndex; *(ptr2--) = *(ptr3++); *(ptr2--) = *(ptr3++); *(ptr2--) = *(ptr3++); *ptr2 = *ptr3; value = num; } } bufferIndex += 4; return true; } bufferIndex = bufferEnd; value = 0u; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_4_Float32(out float value) { if (HasBufferData(4)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_Unaligned_Float32_Reads) { value = *(float*)(ptr + bufferIndex); } else { float num = 0f; *(int*)(&num) = *(int*)(ptr + bufferIndex); value = num; } } else { float num2 = 0f; byte* ptr2 = (byte*)(&num2) + 3; byte* ptr3 = ptr + bufferIndex; *(ptr2--) = *(ptr3++); *(ptr2--) = *(ptr3++); *(ptr2--) = *(ptr3++); *ptr2 = *ptr3; value = num2; } } bufferIndex += 4; return true; } bufferIndex = bufferEnd; value = 0f; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_8_Int64(out long value) { if (HasBufferData(8)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { value = *(long*)(ptr + bufferIndex); } else { long num = 0L; int* ptr2 = (int*)(&num); int* ptr3 = (int*)(ptr + bufferIndex); *(ptr2++) = *(ptr3++); *ptr2 = *ptr3; value = num; } } else { long num2 = 0L; byte* ptr4 = (byte*)(&num2) + 7; byte* ptr5 = ptr + bufferIndex; *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *ptr4 = *ptr5; value = num2; } } bufferIndex += 8; return true; } bufferIndex = bufferEnd; value = 0L; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_8_UInt64(out ulong value) { if (HasBufferData(8)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { value = *(ulong*)(ptr + bufferIndex); } else { ulong num = 0uL; int* ptr2 = (int*)(&num); int* ptr3 = (int*)(ptr + bufferIndex); *(ptr2++) = *(ptr3++); *ptr2 = *ptr3; value = num; } } else { ulong num2 = 0uL; byte* ptr4 = (byte*)(&num2) + 7; byte* ptr5 = ptr + bufferIndex; *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *ptr4 = *ptr5; value = num2; } } bufferIndex += 8; return true; } bufferIndex = bufferEnd; value = 0uL; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_8_Float64(out double value) { if (HasBufferData(8)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { value = *(double*)(ptr + bufferIndex); } else { double num = 0.0; int* ptr2 = (int*)(&num); int* ptr3 = (int*)(ptr + bufferIndex); *(ptr2++) = *(ptr3++); *ptr2 = *ptr3; value = num; } } else { double num2 = 0.0; byte* ptr4 = (byte*)(&num2) + 7; byte* ptr5 = ptr + bufferIndex; *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *ptr4 = *ptr5; value = num2; } } bufferIndex += 8; return true; } bufferIndex = bufferEnd; value = 0.0; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_16_Decimal(out decimal value) { if (HasBufferData(16)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { value = *(decimal*)(ptr + bufferIndex); } else { decimal num = default(decimal); int* ptr2 = (int*)(&num); int* ptr3 = (int*)(ptr + bufferIndex); *(ptr2++) = *(ptr3++); *(ptr2++) = *(ptr3++); *(ptr2++) = *(ptr3++); *ptr2 = *ptr3; value = num; } } else { decimal num2 = default(decimal); byte* ptr4 = (byte*)(&num2) + 15; byte* ptr5 = ptr + bufferIndex; *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *ptr4 = *ptr5; value = num2; } } bufferIndex += 16; return true; } bufferIndex = bufferEnd; value = default(decimal); return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe bool UNSAFE_Read_16_Guid(out Guid value) { if (HasBufferData(16)) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { value = *(Guid*)(ptr + bufferIndex); } else { Guid guid = default(Guid); int* ptr2 = (int*)(&guid); int* ptr3 = (int*)(ptr + bufferIndex); *(ptr2++) = *(ptr3++); *(ptr2++) = *(ptr3++); *(ptr2++) = *(ptr3++); *ptr2 = *ptr3; value = guid; } } else { Guid guid2 = default(Guid); byte* ptr4 = (byte*)(&guid2); byte* ptr5 = ptr + bufferIndex; *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *(ptr4++) = *(ptr5++); *ptr4 = *(ptr5++); ptr4 += 6; *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *(ptr4--) = *(ptr5++); *ptr4 = *ptr5; value = guid2; } } bufferIndex += 16; return true; } bufferIndex = bufferEnd; value = default(Guid); return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private bool HasBufferData(int amount) { if (bufferEnd == 0) { ReadEntireStreamToBuffer(); } return bufferIndex + amount <= bufferEnd; } private void ReadEntireStreamToBuffer() { bufferIndex = 0; if (Stream is MemoryStream) { try { buffer = (Stream as MemoryStream).GetBuffer(); bufferEnd = (int)Stream.Length; bufferIndex = (int)Stream.Position; return; } catch (UnauthorizedAccessException) { } } buffer = internalBufferBackup; int num = (int)(Stream.Length - Stream.Position); if (buffer.Length >= num) { Stream.Read(buffer, 0, num); } else { buffer = new byte[num]; Stream.Read(buffer, 0, num); if (num <= 10485760) { internalBufferBackup = buffer; } } bufferIndex = 0; bufferEnd = num; } } public class BinaryDataWriter : BaseDataWriter { private struct Struct256Bit { public decimal d1; public decimal d2; } [StructLayout(LayoutKind.Explicit, Size = 8)] private struct SixtyFourBitValueToByteUnion { [FieldOffset(0)] public byte b0; [FieldOffset(1)] public byte b1; [FieldOffset(2)] public byte b2; [FieldOffset(3)] public byte b3; [FieldOffset(4)] public byte b4; [FieldOffset(5)] public byte b5; [FieldOffset(6)] public byte b6; [FieldOffset(7)] public byte b7; [FieldOffset(0)] public double doubleValue; [FieldOffset(0)] public ulong ulongValue; [FieldOffset(0)] public long longValue; } [StructLayout(LayoutKind.Explicit, Size = 16)] private struct OneTwentyEightBitValueToByteUnion { [FieldOffset(0)] public byte b0; [FieldOffset(1)] public byte b1; [FieldOffset(2)] public byte b2; [FieldOffset(3)] public byte b3; [FieldOffset(4)] public byte b4; [FieldOffset(5)] public byte b5; [FieldOffset(6)] public byte b6; [FieldOffset(7)] public byte b7; [FieldOffset(8)] public byte b8; [FieldOffset(9)] public byte b9; [FieldOffset(10)] public byte b10; [FieldOffset(11)] public byte b11; [FieldOffset(12)] public byte b12; [FieldOffset(13)] public byte b13; [FieldOffset(14)] public byte b14; [FieldOffset(15)] public byte b15; [FieldOffset(0)] public Guid guidValue; [FieldOffset(0)] public decimal decimalValue; } private static readonly Dictionary<Type, Delegate> PrimitiveGetBytesMethods = new Dictionary<Type, Delegate>(FastTypeComparer.Instance) { { typeof(char), (Action<byte[], int, char>)delegate(byte[] b, int i, char v) { ProperBitConverter.GetBytes(b, i, v); } }, { typeof(byte), (Action<byte[], int, byte>)delegate(byte[] b, int i, byte v) { b[i] = v; } }, { typeof(sbyte), (Action<byte[], int, sbyte>)delegate(byte[] b, int i, sbyte v) { b[i] = (byte)v; } }, { typeof(bool), (Action<byte[], int, bool>)delegate(byte[] b, int i, bool v) { b[i] = (v ? ((byte)1) : ((byte)0)); } }, { typeof(short), new Action<byte[], int, short>(ProperBitConverter.GetBytes) }, { typeof(int), new Action<byte[], int, int>(ProperBitConverter.GetBytes) }, { typeof(long), new Action<byte[], int, long>(ProperBitConverter.GetBytes) }, { typeof(ushort), new Action<byte[], int, ushort>(ProperBitConverter.GetBytes) }, { typeof(uint), new Action<byte[], int, uint>(ProperBitConverter.GetBytes) }, { typeof(ulong), new Action<byte[], int, ulong>(ProperBitConverter.GetBytes) }, { typeof(decimal), new Action<byte[], int, decimal>(ProperBitConverter.GetBytes) }, { typeof(float), new Action<byte[], int, float>(ProperBitConverter.GetBytes) }, { typeof(double), new Action<byte[], int, double>(ProperBitConverter.GetBytes) }, { typeof(Guid), new Action<byte[], int, Guid>(ProperBitConverter.GetBytes) } }; private static readonly Dictionary<Type, int> PrimitiveSizes = new Dictionary<Type, int>(FastTypeComparer.Instance) { { typeof(char), 2 }, { typeof(byte), 1 }, { typeof(sbyte), 1 }, { typeof(bool), 1 }, { typeof(short), 2 }, { typeof(int), 4 }, { typeof(long), 8 }, { typeof(ushort), 2 }, { typeof(uint), 4 }, { typeof(ulong), 8 }, { typeof(decimal), 16 }, { typeof(float), 4 }, { typeof(double), 8 }, { typeof(Guid), 16 } }; private readonly byte[] small_buffer = new byte[16]; private readonly byte[] buffer = new byte[102400]; private int bufferIndex; private readonly Dictionary<Type, int> types = new Dictionary<Type, int>(16, FastTypeComparer.Instance); public bool CompressStringsTo8BitWhenPossible; private static readonly Dictionary<Type, Action<BinaryDataWriter, object>> PrimitiveArrayWriters = new Dictionary<Type, Action<BinaryDataWriter, object>>(FastTypeComparer.Instance) { { typeof(char), WritePrimitiveArray_char }, { typeof(sbyte), WritePrimitiveArray_sbyte }, { typeof(short), WritePrimitiveArray_short }, { typeof(int), WritePrimitiveArray_int }, { typeof(long), WritePrimitiveArray_long }, { typeof(byte), WritePrimitiveArray_byte }, { typeof(ushort), WritePrimitiveArray_ushort }, { typeof(uint), WritePrimitiveArray_uint }, { typeof(ulong), WritePrimitiveArray_ulong }, { typeof(decimal), WritePrimitiveArray_decimal }, { typeof(bool), WritePrimitiveArray_bool }, { typeof(float), WritePrimitiveArray_float }, { typeof(double), WritePrimitiveArray_double }, { typeof(Guid), WritePrimitiveArray_Guid } }; public BinaryDataWriter() : base(null, null) { } public BinaryDataWriter(Stream stream, SerializationContext context) : base(stream, context) { } public override void BeginArrayNode(long length) { EnsureBufferSpace(9); buffer[bufferIndex++] = 6; UNSAFE_WriteToBuffer_8_Int64(length); PushArray(); } public override void BeginReferenceNode(string name, Type type, int id) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 1; WriteStringFast(name); } else { EnsureBufferSpace(1); buffer[bufferIndex++] = 2; } WriteType(type); EnsureBufferSpace(4); UNSAFE_WriteToBuffer_4_Int32(id); PushNode(name, id, type); } public override void BeginStructNode(string name, Type type) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 3; WriteStringFast(name); } else { EnsureBufferSpace(1); buffer[bufferIndex++] = 4; } WriteType(type); PushNode(name, -1, type); } public override void Dispose() { FlushToStream(); } public override void EndArrayNode() { PopArray(); EnsureBufferSpace(1); buffer[bufferIndex++] = 7; } public override void EndNode(string name) { PopNode(name); EnsureBufferSpace(1); buffer[bufferIndex++] = 5; } private static void WritePrimitiveArray_byte(BinaryDataWriter writer, object o) { byte[] array = o as byte[]; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(1); writer.FlushToStream(); writer.Stream.Write(array, 0, array.Length); } private unsafe static void WritePrimitiveArray_sbyte(BinaryDataWriter writer, object o) { sbyte[] array = o as sbyte[]; int num = 1; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { fixed (byte* ptr2 = writer.buffer) { fixed (sbyte* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_bool(BinaryDataWriter writer, object o) { bool[] array = o as bool[]; int num = 1; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { fixed (byte* ptr2 = writer.buffer) { fixed (bool* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_char(BinaryDataWriter writer, object o) { char[] array = o as char[]; int num = 2; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (char* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_2_Char(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_short(BinaryDataWriter writer, object o) { short[] array = o as short[]; int num = 2; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (short* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_2_Int16(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_int(BinaryDataWriter writer, object o) { int[] array = o as int[]; int num = 4; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (int* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_4_Int32(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_long(BinaryDataWriter writer, object o) { long[] array = o as long[]; int num = 8; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (long* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_8_Int64(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_ushort(BinaryDataWriter writer, object o) { ushort[] array = o as ushort[]; int num = 2; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (ushort* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_2_UInt16(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_uint(BinaryDataWriter writer, object o) { uint[] array = o as uint[]; int num = 4; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (uint* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_4_UInt32(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_ulong(BinaryDataWriter writer, object o) { ulong[] array = o as ulong[]; int num = 8; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (ulong* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_8_UInt64(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_decimal(BinaryDataWriter writer, object o) { decimal[] array = o as decimal[]; int num = 16; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (decimal* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_16_Decimal(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_float(BinaryDataWriter writer, object o) { float[] array = o as float[]; int num = 4; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (float* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_4_Float32(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_double(BinaryDataWriter writer, object o) { double[] array = o as double[]; int num = 8; int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (double* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_8_Float64(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } private unsafe static void WritePrimitiveArray_Guid(BinaryDataWriter writer, object o) { Guid[] array = o as Guid[]; int num = sizeof(Guid); int num2 = array.Length * num; writer.EnsureBufferSpace(9); writer.buffer[writer.bufferIndex++] = 8; writer.UNSAFE_WriteToBuffer_4_Int32(array.Length); writer.UNSAFE_WriteToBuffer_4_Int32(num); if (writer.TryEnsureBufferSpace(num2)) { if (BitConverter.IsLittleEndian) { fixed (byte* ptr2 = writer.buffer) { fixed (Guid* ptr = array) { void* from = ptr; void* to = ptr2 + writer.bufferIndex; UnsafeUtilities.MemoryCopy(from, to, num2); } } writer.bufferIndex += num2; } else { for (int i = 0; i < array.Length; i++) { writer.UNSAFE_WriteToBuffer_16_Guid(array[i]); } } return; } writer.FlushToStream(); using Buffer<byte> buffer = Buffer<byte>.Claim(num2); if (BitConverter.IsLittleEndian) { UnsafeUtilities.MemoryCopy(array, buffer.Array, num2, 0, 0); } else { byte[] array2 = buffer.Array; for (int j = 0; j < array.Length; j++) { ProperBitConverter.GetBytes(array2, j * num, array[j]); } } writer.Stream.Write(buffer.Array, 0, num2); } public override void WritePrimitiveArray<T>(T[] array) { if (!PrimitiveArrayWriters.TryGetValue(typeof(T), out var value)) { throw new ArgumentException("Type " + typeof(T).Name + " is not a valid primitive array type."); } value(this, array); } public override void WriteBoolean(string name, bool value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 43; WriteStringFast(name); EnsureBufferSpace(1); buffer[bufferIndex++] = (value ? ((byte)1) : ((byte)0)); } else { EnsureBufferSpace(2); buffer[bufferIndex++] = 44; buffer[bufferIndex++] = (value ? ((byte)1) : ((byte)0)); } } public override void WriteByte(string name, byte value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 17; WriteStringFast(name); EnsureBufferSpace(1); buffer[bufferIndex++] = value; } else { EnsureBufferSpace(2); buffer[bufferIndex++] = 18; buffer[bufferIndex++] = value; } } public override void WriteChar(string name, char value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 37; WriteStringFast(name); EnsureBufferSpace(2); UNSAFE_WriteToBuffer_2_Char(value); } else { EnsureBufferSpace(3); buffer[bufferIndex++] = 38; UNSAFE_WriteToBuffer_2_Char(value); } } public override void WriteDecimal(string name, decimal value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 35; WriteStringFast(name); EnsureBufferSpace(16); UNSAFE_WriteToBuffer_16_Decimal(value); } else { EnsureBufferSpace(17); buffer[bufferIndex++] = 36; UNSAFE_WriteToBuffer_16_Decimal(value); } } public override void WriteDouble(string name, double value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 33; WriteStringFast(name); EnsureBufferSpace(8); UNSAFE_WriteToBuffer_8_Float64(value); } else { EnsureBufferSpace(9); buffer[bufferIndex++] = 34; UNSAFE_WriteToBuffer_8_Float64(value); } } public override void WriteGuid(string name, Guid value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 41; WriteStringFast(name); EnsureBufferSpace(16); UNSAFE_WriteToBuffer_16_Guid(value); } else { EnsureBufferSpace(17); buffer[bufferIndex++] = 42; UNSAFE_WriteToBuffer_16_Guid(value); } } public override void WriteExternalReference(string name, Guid guid) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 13; WriteStringFast(name); EnsureBufferSpace(16); UNSAFE_WriteToBuffer_16_Guid(guid); } else { EnsureBufferSpace(17); buffer[bufferIndex++] = 14; UNSAFE_WriteToBuffer_16_Guid(guid); } } public override void WriteExternalReference(string name, int index) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 11; WriteStringFast(name); EnsureBufferSpace(4); UNSAFE_WriteToBuffer_4_Int32(index); } else { EnsureBufferSpace(5); buffer[bufferIndex++] = 12; UNSAFE_WriteToBuffer_4_Int32(index); } } public override void WriteExternalReference(string name, string id) { if (id == null) { throw new ArgumentNullException("id"); } if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 50; WriteStringFast(name); } else { EnsureBufferSpace(1); buffer[bufferIndex++] = 51; } WriteStringFast(id); } public override void WriteInt32(string name, int value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 23; WriteStringFast(name); EnsureBufferSpace(4); UNSAFE_WriteToBuffer_4_Int32(value); } else { EnsureBufferSpace(5); buffer[bufferIndex++] = 24; UNSAFE_WriteToBuffer_4_Int32(value); } } public override void WriteInt64(string name, long value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 27; WriteStringFast(name); EnsureBufferSpace(8); UNSAFE_WriteToBuffer_8_Int64(value); } else { EnsureBufferSpace(9); buffer[bufferIndex++] = 28; UNSAFE_WriteToBuffer_8_Int64(value); } } public override void WriteNull(string name) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 45; WriteStringFast(name); } else { EnsureBufferSpace(1); buffer[bufferIndex++] = 46; } } public override void WriteInternalReference(string name, int id) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 9; WriteStringFast(name); EnsureBufferSpace(4); UNSAFE_WriteToBuffer_4_Int32(id); } else { EnsureBufferSpace(5); buffer[bufferIndex++] = 10; UNSAFE_WriteToBuffer_4_Int32(id); } } public override void WriteSByte(string name, sbyte value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 15; WriteStringFast(name); EnsureBufferSpace(1); buffer[bufferIndex++] = (byte)value; } else { EnsureBufferSpace(2); buffer[bufferIndex++] = 16; buffer[bufferIndex++] = (byte)value; } } public override void WriteInt16(string name, short value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 19; WriteStringFast(name); EnsureBufferSpace(2); UNSAFE_WriteToBuffer_2_Int16(value); } else { EnsureBufferSpace(3); buffer[bufferIndex++] = 20; UNSAFE_WriteToBuffer_2_Int16(value); } } public override void WriteSingle(string name, float value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 31; WriteStringFast(name); EnsureBufferSpace(4); UNSAFE_WriteToBuffer_4_Float32(value); } else { EnsureBufferSpace(5); buffer[bufferIndex++] = 32; UNSAFE_WriteToBuffer_4_Float32(value); } } public override void WriteString(string name, string value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 39; WriteStringFast(name); } else { EnsureBufferSpace(1); buffer[bufferIndex++] = 40; } WriteStringFast(value); } public override void WriteUInt32(string name, uint value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 25; WriteStringFast(name); EnsureBufferSpace(4); UNSAFE_WriteToBuffer_4_UInt32(value); } else { EnsureBufferSpace(5); buffer[bufferIndex++] = 26; UNSAFE_WriteToBuffer_4_UInt32(value); } } public override void WriteUInt64(string name, ulong value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 29; WriteStringFast(name); EnsureBufferSpace(8); UNSAFE_WriteToBuffer_8_UInt64(value); } else { EnsureBufferSpace(9); buffer[bufferIndex++] = 30; UNSAFE_WriteToBuffer_8_UInt64(value); } } public override void WriteUInt16(string name, ushort value) { if (name != null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 21; WriteStringFast(name); EnsureBufferSpace(2); UNSAFE_WriteToBuffer_2_UInt16(value); } else { EnsureBufferSpace(3); buffer[bufferIndex++] = 22; UNSAFE_WriteToBuffer_2_UInt16(value); } } public override void PrepareNewSerializationSession() { base.PrepareNewSerializationSession(); types.Clear(); bufferIndex = 0; } public override string GetDataDump() { if (!Stream.CanRead) { return "Binary data stream for writing cannot be read; cannot dump data."; } if (!Stream.CanSeek) { return "Binary data stream cannot seek; cannot dump data."; } FlushToStream(); long position = Stream.Position; byte[] bytes = new byte[position]; Stream.Position = 0L; Stream.Read(bytes, 0, (int)position); Stream.Position = position; return "Binary hex dump: " + ProperBitConverter.BytesToHexString(bytes); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private void WriteType(Type type) { if (type == null) { EnsureBufferSpace(1); buffer[bufferIndex++] = 46; return; } if (types.TryGetValue(type, out var value)) { EnsureBufferSpace(5); buffer[bufferIndex++] = 48; UNSAFE_WriteToBuffer_4_Int32(value); return; } value = types.Count; types.Add(type, value); EnsureBufferSpace(5); buffer[bufferIndex++] = 47; UNSAFE_WriteToBuffer_4_Int32(value); WriteStringFast(base.Context.Binder.BindToName(type, base.Context.Config.DebugContext)); } private unsafe void WriteStringFast(string value) { bool flag = true; if (CompressStringsTo8BitWhenPossible) { flag = false; for (int i = 0; i < value.Length; i++) { if (value[i] > 'ÿ') { flag = true; break; } } } int num; if (flag) { num = value.Length * 2; if (TryEnsureBufferSpace(num + 5)) { this.buffer[bufferIndex++] = 1; UNSAFE_WriteToBuffer_4_Int32(value.Length); if (BitConverter.IsLittleEndian) { fixed (byte* ptr = this.buffer) { fixed (char* ptr3 = value) { Struct256Bit* ptr2 = (Struct256Bit*)(ptr + bufferIndex); Struct256Bit* ptr4 = (Struct256Bit*)ptr3; byte* ptr5 = (byte*)ptr2 + num; while (ptr2 + 1 <= ptr5) { *(ptr2++) = *(ptr4++); } char* ptr6 = (char*)ptr2; char* ptr7 = (char*)ptr4; while (ptr6 < ptr5) { *(ptr6++) = *(ptr7++); } } } } else { fixed (byte* ptr8 = this.buffer) { fixed (char* ptr10 = value) { byte* ptr9 = ptr8 + bufferIndex; byte* ptr11 = (byte*)ptr10; for (int j = 0; j < num; j += 2) { *ptr9 = ptr11[1]; ptr9[1] = *ptr11; ptr11 += 2; ptr9 += 2; } } } } bufferIndex += num; return; } FlushToStream(); Stream.WriteByte(1); ProperBitConverter.GetBytes(small_buffer, 0, value.Length); Stream.Write(small_buffer, 0, 4); using Buffer<byte> buffer = Buffer<byte>.Claim(num); byte[] array = buffer.Array; UnsafeUtilities.StringToBytes(array, value, needs16BitSupport: true); Stream.Write(array, 0, num); return; } num = value.Length; if (TryEnsureBufferSpace(num + 5)) { this.buffer[bufferIndex++] = 0; UNSAFE_WriteToBuffer_4_Int32(value.Length); for (int k = 0; k < num; k++) { this.buffer[bufferIndex++] = (byte)value[k]; } return; } FlushToStream(); Stream.WriteByte(0); ProperBitConverter.GetBytes(small_buffer, 0, value.Length); Stream.Write(small_buffer, 0, 4); using Buffer<byte> buffer2 = Buffer<byte>.Claim(value.Length); byte[] array2 = buffer2.Array; for (int l = 0; l < value.Length; l++) { array2[l] = (byte)value[l]; } Stream.Write(array2, 0, value.Length); } public override void FlushToStream() { if (bufferIndex > 0) { Stream.Write(buffer, 0, bufferIndex); bufferIndex = 0; } base.FlushToStream(); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe void UNSAFE_WriteToBuffer_2_Char(char value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { *(char*)(ptr + bufferIndex) = value; } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 1; *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 2; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe void UNSAFE_WriteToBuffer_2_Int16(short value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { *(short*)(ptr + bufferIndex) = value; } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 1; *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 2; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe void UNSAFE_WriteToBuffer_2_UInt16(ushort value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { *(ushort*)(ptr + bufferIndex) = value; } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 1; *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 2; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe void UNSAFE_WriteToBuffer_4_Int32(int value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { *(int*)(ptr + bufferIndex) = value; } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 3; *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 4; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe void UNSAFE_WriteToBuffer_4_UInt32(uint value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { *(uint*)(ptr + bufferIndex) = value; } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 3; *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 4; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe void UNSAFE_WriteToBuffer_4_Float32(float value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { *(float*)(ptr + bufferIndex) = value; } else { byte* ptr2 = (byte*)(&value); byte* ptr3 = ptr + bufferIndex; *(ptr3++) = *(ptr2++); *(ptr3++) = *(ptr2++); *(ptr3++) = *(ptr2++); *ptr3 = *ptr2; } } else { byte* ptr4 = ptr + bufferIndex; byte* ptr5 = (byte*)(&value) + 3; *(ptr4++) = *(ptr5--); *(ptr4++) = *(ptr5--); *(ptr4++) = *(ptr5--); *ptr4 = *ptr5; } } bufferIndex += 4; } [MethodImpl(MethodImplOptions.NoInlining)] private unsafe void UNSAFE_WriteToBuffer_8_Int64(long value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { *(long*)(ptr + bufferIndex) = value; } else { SixtyFourBitValueToByteUnion sixtyFourBitValueToByteUnion = default(SixtyFourBitValueToByteUnion); sixtyFourBitValueToByteUnion.longValue = value; buffer[bufferIndex] = sixtyFourBitValueToByteUnion.b0; buffer[bufferIndex + 1] = sixtyFourBitValueToByteUnion.b1; buffer[bufferIndex + 2] = sixtyFourBitValueToByteUnion.b2; buffer[bufferIndex + 3] = sixtyFourBitValueToByteUnion.b3; buffer[bufferIndex + 4] = sixtyFourBitValueToByteUnion.b4; buffer[bufferIndex + 5] = sixtyFourBitValueToByteUnion.b5; buffer[bufferIndex + 6] = sixtyFourBitValueToByteUnion.b6; buffer[bufferIndex + 7] = sixtyFourBitValueToByteUnion.b7; } } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 7; *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 8; } [MethodImpl(MethodImplOptions.NoInlining)] private unsafe void UNSAFE_WriteToBuffer_8_UInt64(ulong value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { *(ulong*)(ptr + bufferIndex) = value; } else { SixtyFourBitValueToByteUnion sixtyFourBitValueToByteUnion = default(SixtyFourBitValueToByteUnion); sixtyFourBitValueToByteUnion.ulongValue = value; buffer[bufferIndex] = sixtyFourBitValueToByteUnion.b0; buffer[bufferIndex + 1] = sixtyFourBitValueToByteUnion.b1; buffer[bufferIndex + 2] = sixtyFourBitValueToByteUnion.b2; buffer[bufferIndex + 3] = sixtyFourBitValueToByteUnion.b3; buffer[bufferIndex + 4] = sixtyFourBitValueToByteUnion.b4; buffer[bufferIndex + 5] = sixtyFourBitValueToByteUnion.b5; buffer[bufferIndex + 6] = sixtyFourBitValueToByteUnion.b6; buffer[bufferIndex + 7] = sixtyFourBitValueToByteUnion.b7; } } else { byte* ptr2 = ptr + bufferIndex; byte* ptr3 = (byte*)(&value) + 7; *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *(ptr2++) = *(ptr3--); *ptr2 = *ptr3; } } bufferIndex += 8; } [MethodImpl(MethodImplOptions.NoInlining)] private unsafe void UNSAFE_WriteToBuffer_8_Float64(double value) { fixed (byte* ptr = buffer) { if (BitConverter.IsLittleEndian) { if (ArchitectureInfo.Architecture_Supports_All_Unaligned_ReadWrites) { *(double*)(ptr + bufferIndex) = value; } else { SixtyFourBitValueToByteUnion sixtyFourBitValueToByteUnion = default(SixtyFourBitValueToByteUnion); sixtyFourBitValueToByteUnion.doubleValue = value; buffer[bufferIndex] = sixtyFourBitValueToByteUnion.b0; buffer[bufferIndex + 1] = sixtyFourBitValueToByteUnion.b1;

Lethal Company

OdinSerializer

Details

Categories

BepInEx/core/OdinSerializer/OdinSerializer.dll

Categories

BepInEx/core/OdinSerializer/OdinSerializer.dll

Categories