using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Microsoft.CodeAnalysis;
using io.wispforest.impl;
using io.wispforest.util;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace io.wispforest
{
	public interface Deserializer<out T> where T : class
	{
		SerializationContext setupContext(SerializationContext ctx)
		{
			return ctx;
		}

		byte readByte(SerializationContext ctx);

		short readShort(SerializationContext ctx);

		int readInt(SerializationContext ctx);

		long readLong(SerializationContext ctx);

		float readFloat(SerializationContext ctx);

		double readDouble(SerializationContext ctx);

		int readVarInt(SerializationContext ctx);

		long readVarLong(SerializationContext ctx);

		bool readBoolean(SerializationContext ctx);

		string readString(SerializationContext ctx);

		byte[] readBytes(SerializationContext ctx);

		V? readOptional<V>(SerializationContext ctx, Endec<V> endec);

		SequenceDeserializer<E> sequence<E>(SerializationContext ctx, Endec<E> elementEndec);

		MapDeserializer<V> map<V>(SerializationContext ctx, Endec<V> valueEndec);

		StructDeserializer structed();

		V tryRead<V>(Func<Deserializer<T>, V> reader);
	}
	public interface SequenceDeserializer<E> : IEnumerator<E>, IEnumerator, IDisposable, IEnumerable<E>, IEnumerable
	{
		object? IEnumerator.Current => Current;

		IEnumerator<E> IEnumerable<E>.GetEnumerator()
		{
			return this;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return this;
		}

		int estimatedSize();
	}
	public interface MapDeserializer<E> : IEnumerator<KeyValuePair<string, E>>, IEnumerator, IDisposable, IEnumerable<KeyValuePair<string, E>>, IEnumerable
	{
		object? IEnumerator.Current => Current;

		IEnumerator<KeyValuePair<string, E>> IEnumerable<KeyValuePair<string, E>>.GetEnumerator()
		{
			return this;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return this;
		}

		int estimatedSize();
	}
	public interface StructDeserializer
	{
		F? field<F>(string name, SerializationContext ctx, Endec<F> endec)
		{
			return field(name, ctx, endec, null);
		}

		F? field<F>(string name, SerializationContext ctx, Endec<F> endec, Func<F>? defaultValueFactory);
	}
	public interface SelfDescribedDeserializer<out T> : Deserializer<T> where T : class
	{
		void readAny<S>(SerializationContext ctx, Serializer<S> visitor) where S : class;
	}
	public delegate T IntFunction<T>(int size);
	public delegate void Encoder<T>(SerializationContext ctx, Serializer<dynamic> serializer, T value);
	public delegate T Decoder<T>(SerializationContext ctx, Deserializer<dynamic> deserializer);
	public delegate T DecoderWithError<T>(SerializationContext ctx, Deserializer<dynamic> deserializer, Exception exception);
	public abstract class Endec<T>
	{
		public abstract void encode<E>(SerializationContext ctx, Serializer<E> serializer, T value) where E : class;

		public abstract T decode<E>(SerializationContext ctx, Deserializer<E> deserializer) where E : class;

		public E encodeFully<E>(SerializationContext ctx, Func<Serializer<E>> serializerConstructor, T value) where E : class
		{
			Serializer<E> serializer = serializerConstructor();
			encode(serializer.setupContext(ctx), serializer, value);
			return serializer.result();
		}

		public E encodeFully<E>(Func<Serializer<E>> serializerConstructor, T value) where E : class
		{
			return encodeFully(SerializationContext.empty(), serializerConstructor, value);
		}

		public T decodeFully<E>(SerializationContext ctx, Func<E, Deserializer<E>> deserializerConstructor, E value) where E : class
		{
			Deserializer<E> deserializer = deserializerConstructor(value);
			return decode(deserializer.setupContext(ctx), deserializer);
		}

		public T decodeFully<E>(Func<E, Deserializer<E>> deserializerConstructor, E value) where E : class
		{
			return decodeFully(SerializationContext.empty(), deserializerConstructor, value);
		}

		public Endec<IList<T>> listOf()
		{
			return EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, IList<T> list)
			{
				using SequenceSerializer<T> sequenceSerializer = serializer.sequence(ctx, this, list.Count);
				foreach (T item in list)
				{
					sequenceSerializer.element(item);
				}
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer)
			{
				SequenceDeserializer<T> sequenceDeserializer = deserializer.sequence(ctx, this);
				List<T> list2 = new List<T>(sequenceDeserializer.estimatedSize());
				foreach (T item2 in sequenceDeserializer)
				{
					list2.Add(item2);
				}
				return list2;
			});
		}

		public Endec<T[]> arrayOf()
		{
			return listOf().xmap((IList<T> list) => list.ToArray(), (T[] array) => new List<T>(array));
		}

		public Endec<IDictionary<string, T>> mapOf()
		{
			return mapOf(EndecUtils.DefaultDictionary<string, T>());
		}

		public Endec<M> mapOf<M>(IntFunction<M> mapConstructor) where M : IDictionary<string, T>
		{
			IntFunction<M> mapConstructor2 = mapConstructor;
			return EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, M map)
			{
				using MapSerializer<T> mapSerializer = serializer.map(ctx, this, map.Count);
				foreach (KeyValuePair<string, T> item in map)
				{
					mapSerializer.entry(item.Key, item.Value);
				}
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer)
			{
				MapDeserializer<T> mapDeserializer = deserializer.map(ctx, this);
				M result = mapConstructor2(mapDeserializer.estimatedSize());
				foreach (KeyValuePair<string, T> item2 in mapDeserializer)
				{
					ref M reference = ref result;
					M val = default(M);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					reference[item2.Key] = item2.Value;
				}
				return result;
			});
		}

		public Endec<IDictionary<K, T>> mapOf<K>(Func<K, string> keyToString, Func<string, K> stringToKey)
		{
			return mapOf(EndecUtils.DefaultDictionary<K, T>(), keyToString, stringToKey);
		}

		public Endec<M> mapOf<K, M>(IntFunction<M> mapConstructor, Func<K, string> keyToString, Func<string, K> stringToKey) where M : IDictionary<K, T>
		{
			return EndecUtils.map(mapConstructor, keyToString, stringToKey, this);
		}

		public Endec<T?> optionalOf()
		{
			return EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, T value)
			{
				serializer.writeOptional(ctx, this, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readOptional(ctx, this));
		}

		public Endec<R> xmap<R>(Func<T, R> to, Func<R, T> from)
		{
			Func<R, T> from2 = from;
			Func<T, R> to2 = to;
			return EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, R value)
			{
				encode(ctx, serializer, from2(value));
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => to2(decode(ctx, deserializer)));
		}

		public Endec<R> xmapWithContext<R>(Func<SerializationContext, T, R> to, Func<SerializationContext, R, T> from)
		{
			Func<SerializationContext, R, T> from2 = from;
			Func<SerializationContext, T, R> to2 = to;
			return EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, R value)
			{
				encode(ctx, serializer, from2(ctx, value));
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => to2(ctx, decode(ctx, deserializer)));
		}

		public Endec<T> validate(Action<T> validator)
		{
			Action<T> validator2 = validator;
			return xmap(delegate(T t)
			{
				validator2(t);
				return t;
			}, delegate(T t)
			{
				validator2(t);
				return t;
			});
		}

		public Endec<T> catchErrors(DecoderWithError<T> decodeOnError)
		{
			DecoderWithError<T> decodeOnError2 = decodeOnError;
			return EndecUtils.of(encode, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer)
			{
				SerializationContext ctx2 = ctx;
				try
				{
					return deserializer.tryRead((Deserializer<dynamic> deserializer1) => decode(ctx2, deserializer1));
				}
				catch (Exception exception)
				{
					return decodeOnError2(ctx2, deserializer, exception);
				}
			});
		}

		public Endec<ISet<T>> setOf()
		{
			return listOf().xmap((IList<T> list) => new HashSet<T>(list), (ISet<T> set) => new List<T>(set));
		}

		public KeyedEndec<T> keyed(string key, T defaultValue)
		{
			return new KeyedEndec<T>(key, this, defaultValue);
		}

		public KeyedEndec<T> keyed(string key, Func<T> defaultValueFactory)
		{
			return new KeyedEndec<T>(key, this, defaultValueFactory);
		}

		public StructEndec<T> structOf(string name)
		{
			string name2 = name;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> _, StructSerializer instance, T value)
			{
				instance.field(name2, ctx, this, value);
			}, (SerializationContext ctx, Deserializer<dynamic> _, StructDeserializer instance) => instance.field(name2, ctx, this));
		}

		public StructField<S, T> fieldOf<S>(string name, Func<S, T> getter)
		{
			return new StructField<S, T>(name, this, getter);
		}

		public StructField<S, T> optionalFieldOf<S>(string name, Func<S, T?> getter)
		{
			return optionalFieldOf(name, getter, null);
		}

		public StructField<S, T> optionalFieldOf<S>(string name, Func<S, T?> getter, T? defaultValue)
		{
			return new StructField<S, T>(name, optionalOf(), getter, defaultValue);
		}

		public StructField<S, T> optionalFieldOf<S>(string name, Func<S, T?> getter, Func<T?> defaultValue)
		{
			if (defaultValue == null)
			{
				throw new NullReferenceException("Supplier was found to be null which is not permitted for optionalFieldOf");
			}
			return new StructField<S, T>(name, optionalOf(), getter, defaultValue);
		}
	}
	public sealed class EndecGetter
	{
		public static Endec<T> Endec<T>() where T : EndecGetter<T>
		{
			return EndecGetter<T>.Endec();
		}
	}
	public interface EndecGetter<T> where T : EndecGetter<T>
	{
		static Endec<T> Endec()
		{
			MethodInfo method = typeof(T).GetMethod("Endec", BindingFlags.Static | BindingFlags.Public);
			object obj = method.Invoke(null, null);
			if (!(obj is Endec<T> result))
			{
				throw new InvalidCastException("Unable to get Endec due to it being the incorrect type!");
			}
			return result;
		}
	}
	public class SerializationAttributes
	{
		public static readonly SerializationAttributeMarker HUMAN_READABLE = SerializationAttribute.marker("human_readable");
	}
	public abstract class SerializationAttribute
	{
		public readonly string name;

		protected SerializationAttribute(string name)
		{
			this.name = name;
		}

		public static SerializationAttributeMarker marker(string name)
		{
			return new SerializationAttributeMarker(name);
		}

		public static SerializationAttributeWithValue<T> withValue<T>(string name)
		{
			return new SerializationAttributeWithValue<T>(name);
		}
	}
	public sealed class SerializationAttributeMarker : SerializationAttribute, SerializationAttributeInstance
	{
		internal SerializationAttributeMarker(string name)
			: base(name)
		{
		}

		public SerializationAttribute attribute()
		{
			return this;
		}

		public object value()
		{
			return null;
		}
	}
	public sealed class SerializationAttributeWithValue<T> : SerializationAttribute
	{
		internal SerializationAttributeWithValue(string name)
			: base(name)
		{
		}

		public SerializationAttributeInstance instance(T value)
		{
			return new InstanceImpl(this, value);
		}
	}
	public interface SerializationAttributeInstance
	{
		SerializationAttribute attribute();

		object value();
	}
	internal class InstanceImpl : SerializationAttributeInstance
	{
		private readonly SerializationAttribute attribute;

		private readonly object value;

		internal InstanceImpl(SerializationAttribute attribute, object value)
		{
			this.attribute = attribute;
			this.value = value;
		}

		SerializationAttribute SerializationAttributeInstance.attribute()
		{
			return attribute;
		}

		object SerializationAttributeInstance.value()
		{
			return value;
		}
	}
	public class SerializationContext
	{
		private static readonly SerializationContext EMPTY = new SerializationContext(new Dictionary<SerializationAttribute, object>(), new HashSet<SerializationAttribute>());

		private readonly IDictionary<SerializationAttribute, object> attributeValues;

		private readonly ISet<SerializationAttribute> suppressedAttributes;

		private SerializationContext(IDictionary<SerializationAttribute, object> attributeValues, ISet<SerializationAttribute> suppressedAttributes)
		{
			this.attributeValues = attributeValues.ImmutableWrap();
			this.suppressedAttributes = suppressedAttributes.ImmutableWrap();
		}

		public static SerializationContext empty()
		{
			return EMPTY;
		}

		public static SerializationContext attributes(params SerializationAttributeInstance[] attributes)
		{
			if (attributes.Length == 0)
			{
				return EMPTY;
			}
			return new SerializationContext(unpackAttributes(attributes), new HashSet<SerializationAttribute>());
		}

		public static SerializationContext suppressed(params SerializationAttribute[] attributes)
		{
			if (attributes.Length == 0)
			{
				return EMPTY;
			}
			return new SerializationContext(new Dictionary<SerializationAttribute, object>(), new HashSet<SerializationAttribute>(attributes));
		}

		public SerializationContext withAttributes(params SerializationAttributeInstance[] attributes)
		{
			IDictionary<SerializationAttribute, object> dictionary = unpackAttributes(attributes);
			foreach (KeyValuePair<SerializationAttribute, object> attributeValue in attributeValues)
			{
				if (!dictionary.ContainsKey(attributeValue.Key))
				{
					dictionary.Add(attributeValue);
				}
			}
			return new SerializationContext(dictionary, suppressedAttributes);
		}

		public SerializationContext withoutAttributes(params SerializationAttribute[] attributes)
		{
			Dictionary<SerializationAttribute, object> dictionary = new Dictionary<SerializationAttribute, object>(attributeValues);
			foreach (SerializationAttribute key in attributes)
			{
				dictionary.Remove(key);
			}
			return new SerializationContext(dictionary, suppressedAttributes);
		}

		public SerializationContext withSuppressed(params SerializationAttribute[] attributes)
		{
			HashSet<SerializationAttribute> set = new HashSet<SerializationAttribute>(suppressedAttributes);
			set.AddAll(attributes);
			return new SerializationContext(attributeValues, set);
		}

		public SerializationContext withoutSuppressed(params SerializationAttribute[] attributes)
		{
			HashSet<SerializationAttribute> hashSet = new HashSet<SerializationAttribute>(suppressedAttributes);
			foreach (SerializationAttribute item in attributes)
			{
				hashSet.Remove(item);
			}
			return new SerializationContext(attributeValues, hashSet);
		}

		public SerializationContext and(SerializationContext other)
		{
			Dictionary<SerializationAttribute, object> dictionary = new Dictionary<SerializationAttribute, object>(attributeValues);
			dictionary.AddAll(other.attributeValues);
			HashSet<SerializationAttribute> set = new HashSet<SerializationAttribute>(suppressedAttributes);
			set.AddAll(other.suppressedAttributes);
			return new SerializationContext(dictionary, set);
		}

		public bool hasAttribute(SerializationAttribute attribute)
		{
			return attributeValues.ContainsKey(attribute) && !suppressedAttributes.Contains(attribute);
		}

		public A getAttributeValue<A>(SerializationAttributeWithValue<A> attribute)
		{
			return (A)attributeValues[attribute];
		}

		public A requireAttributeValue<A>(SerializationAttributeWithValue<A> attribute)
		{
			if (!hasAttribute(attribute))
			{
				throw new MissingAttributeValueException("Context did not provide a value for attribute '" + attribute.name + "'");
			}
			return getAttributeValue(attribute);
		}

		private static IDictionary<SerializationAttribute, object> unpackAttributes(params SerializationAttributeInstance[] attributes)
		{
			Dictionary<SerializationAttribute, object> dictionary = new Dictionary<SerializationAttribute, object>();
			foreach (SerializationAttributeInstance serializationAttributeInstance in attributes)
			{
				dictionary.Add(serializationAttributeInstance.attribute(), serializationAttributeInstance.value());
			}
			return dictionary;
		}
	}
	public interface Serializer<out T> where T : class
	{
		SerializationContext setupContext(SerializationContext ctx)
		{
			return ctx;
		}

		void writeByte(SerializationContext ctx, byte value);

		void writeShort(SerializationContext ctx, short value);

		void writeInt(SerializationContext ctx, int value);

		void writeLong(SerializationContext ctx, long value);

		void writeFloat(SerializationContext ctx, float value);

		void writeDouble(SerializationContext ctx, double value);

		void writeVarInt(SerializationContext ctx, int value);

		void writeVarLong(SerializationContext ctx, long value);

		void writeBoolean(SerializationContext ctx, bool value);

		void writeString(SerializationContext ctx, string value);

		void writeBytes(SerializationContext ctx, byte[] bytes);

		void writeOptional<V>(SerializationContext ctx, Endec<V> endec, V? optional);

		SequenceSerializer<E> sequence<E>(SerializationContext ctx, Endec<E> elementEndec, int size);

		MapSerializer<V> map<V>(SerializationContext ctx, Endec<V> valueEndec, int size);

		StructSerializer structed();

		T result();
	}
	public interface SequenceSerializer<E> : Endable, IDisposable
	{
		void element(E element);
	}
	public interface MapSerializer<V> : Endable, IDisposable
	{
		void entry(string key, V value);
	}
	public interface StructSerializer : Endable, IDisposable
	{
		StructSerializer field<F>(string name, SerializationContext ctx, Endec<F> endec, F value)
		{
			return field(name, ctx, endec, value, mayOmit: false);
		}

		StructSerializer field<F>(string name, SerializationContext ctx, Endec<F> endec, F value, bool mayOmit);
	}
	public interface SelfDescribedSerializer<T> : Serializer<T> where T : class
	{
	}
	public delegate void StructuredEncoder<T>(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, T value);
	public delegate T StructuredDecoder<T>(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance);
	public delegate T StructuredDecoderWithError<T>(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance, Exception exception);
	public abstract class StructEndec<T> : Endec<T>
	{
		public abstract void encodeStruct<E>(SerializationContext ctx, Serializer<E> serializer, StructSerializer instance, T value) where E : class;

		public abstract T decodeStruct<E>(SerializationContext ctx, Deserializer<E> deserializer, StructDeserializer instance) where E : class;

		public override void encode<E>(SerializationContext ctx, Serializer<E> serializer, T value)
		{
			using StructSerializer instance = serializer.structed();
			encodeStruct(ctx, serializer, instance, value);
		}

		public override T decode<E>(SerializationContext ctx, Deserializer<E> deserializer)
		{
			return decodeStruct(ctx, deserializer, deserializer.structed());
		}

		public StructField<S, T> flatFieldOf<S>(Func<S, T> getter)
		{
			return new FlatStructField<S, T>(this, getter);
		}

		public StructField<M, T> flatInheritedFieldOf<M>() where M : T
		{
			return new FlatStructField<M, T>(this, (M m) => (T)(object)m);
		}

		public new StructEndec<R> xmap<R>(Func<T, R> to, Func<R, T> from)
		{
			Func<R, T> from2 = from;
			Func<T, R> to2 = to;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, R value)
			{
				encodeStruct(ctx, serializer, instance, from2(value));
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => to2(decodeStruct(ctx, deserializer, instance)));
		}

		public new StructEndec<R> xmapWithContext<R>(Func<SerializationContext, T, R> to, Func<SerializationContext, R, T> from)
		{
			Func<SerializationContext, R, T> from2 = from;
			Func<SerializationContext, T, R> to2 = to;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, R value)
			{
				encodeStruct(ctx, serializer, instance, from2(ctx, value));
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => to2(ctx, decodeStruct(ctx, deserializer, instance)));
		}

		public StructEndec<T> structuredCatchErrors(StructuredDecoderWithError<T> decodeOnError)
		{
			StructuredDecoderWithError<T> decodeOnError2 = decodeOnError;
			return StructEndecUtils.of(encodeStruct, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance)
			{
				SerializationContext ctx2 = ctx;
				StructDeserializer instance2 = instance;
				try
				{
					return deserializer.tryRead((Deserializer<dynamic> deserializer1) => decodeStruct(ctx2, deserializer1, instance2));
				}
				catch (Exception exception)
				{
					return decodeOnError2(ctx2, deserializer, instance2, exception);
				}
			});
		}

		public new StructEndec<T> validate(Action<T> validator)
		{
			Action<T> validator2 = validator;
			return xmap(delegate(T t)
			{
				validator2(t);
				return t;
			}, delegate(T t)
			{
				validator2(t);
				return t;
			});
		}
	}
	public class StructEndecUtils
	{
		public static StructEndec<T> of<T>(StructuredEncoder<T> encoder, StructuredDecoder<T> decoder)
		{
			return new StructEndecImpl<T>(encoder, decoder);
		}

		private static StructEndec<T> recursive<T>(Func<StructEndec<T>, StructEndec<T>> builderFunc)
		{
			return new RecursiveStructEndec<T>(builderFunc);
		}

		public static AttributeStructEndecBuilder<T> ifAttr<T>(SerializationAttribute attribute, StructEndec<T> endec)
		{
			return new AttributeStructEndecBuilder<T>(endec, attribute);
		}
	}
}
namespace io.wispforest.util
{
	public interface Endable : IDisposable
	{
		void end();

		void IDisposable.Dispose()
		{
			end();
		}
	}
	public class EndecUtils
	{
		public static IntFunction<IDictionary<K, V>> DefaultDictionary<K, V>()
		{
			return (int i) => new Dictionary<K, V>(i);
		}

		public static Endec<T> of<T>(Encoder<T> encoder, Decoder<T> decoder)
		{
			return new EndecImpl<T>(encoder, decoder);
		}

		private static Endec<T> recursive<T>(Func<Endec<T>, Endec<T>> builderFunc)
		{
			return new RecursiveEndec<T>(builderFunc);
		}

		public static StructEndec<T> unit<T>(T instance)
		{
			T instance2 = instance;
			return unit(() => instance2);
		}

		public static StructEndec<T> unit<T>(Func<T> instanceGetter)
		{
			Func<T> instanceGetter2 = instanceGetter;
			return StructEndecUtils.of(delegate
			{
			}, (SerializationContext _, Deserializer<dynamic> _, StructDeserializer _) => instanceGetter2());
		}

		public static Endec<IDictionary<K, V>> map<K, V>(Endec<K> keyEndec, Endec<V> valueEndec)
		{
			return StructEndecBuilder.of(keyEndec.fieldOf("k", (KeyValuePair<K, V> s) => s.Key), valueEndec.fieldOf("v", (KeyValuePair<K, V> s) => s.Value), (K k, V v) => new KeyValuePair<K, V>(k, v)).listOf().xmap(delegate(IList<KeyValuePair<K, V>> entries)
			{
				Dictionary<K, V> dictionary = new Dictionary<K, V>(entries.Count);
				dictionary.AddAll(entries);
				return dictionary;
			}, (IDictionary<K, V> kvMap) => new List<KeyValuePair<K, V>>(kvMap));
		}

		public static Endec<IDictionary<K, V>> map<K, V>(Func<K, string> keyToString, Func<string, K> stringToKey, Endec<V> valueEndec)
		{
			return map(DefaultDictionary<K, V>(), keyToString, stringToKey, valueEndec);
		}

		public static Endec<M> map<K, V, M>(IntFunction<M> mapConstructor, Func<K, string> keyToString, Func<string, K> stringToKey, Endec<V> valueEndec) where M : IDictionary<K, V>
		{
			Endec<V> valueEndec2 = valueEndec;
			Func<K, string> keyToString2 = keyToString;
			IntFunction<M> mapConstructor2 = mapConstructor;
			Func<string, K> stringToKey2 = stringToKey;
			return of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, M map)
			{
				using MapSerializer<V> mapSerializer = serializer.map(ctx, valueEndec2, map.Count);
				foreach (KeyValuePair<K, V> item in map)
				{
					mapSerializer.entry(keyToString2(item.Key), item.Value);
				}
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer)
			{
				MapDeserializer<V> mapDeserializer = deserializer.map(ctx, valueEndec2);
				M result = mapConstructor2(mapDeserializer.estimatedSize());
				foreach (KeyValuePair<string, V> item2 in mapDeserializer)
				{
					ref M reference = ref result;
					M val = default(M);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					reference[stringToKey2(item2.Key)] = item2.Value;
				}
				return result;
			});
		}

		public static Endec<E> forEnum<E>() where E : class, Enum
		{
			return forEnum((E arg) => Enum.GetName(typeof(E), arg));
		}

		public static Endec<E> forEnum<E>(Func<E, string?> nameLookup) where E : class, Enum
		{
			Func<E, string?> nameLookup2 = nameLookup;
			Array enumValues = Enum.GetValues(typeof(E));
			Dictionary<string, E?> serializedNames = new Dictionary<string, E>();
			Dictionary<E, int> entryToIndex = new Dictionary<E, int>();
			int num = 0;
			foreach (E item in enumValues)
			{
				serializedNames[nameLookup2(item)] = item;
				entryToIndex[item] = num;
				num++;
			}
			Type type = typeof(E);
			return ifAttr(SerializationAttributes.HUMAN_READABLE, Endecs.STRING.xmap(delegate(string name)
			{
				E val2 = serializedNames[name];
				if (val2 == null)
				{
					throw new Exception(type.Name + " constant with the name of [" + name + "] could not be located!");
				}
				return val2;
			}, delegate(E value)
			{
				string text = nameLookup2(value);
				if (text == null)
				{
					throw new Exception($"{type.Name} constant with the value of [{value}] could not be located!");
				}
				return text;
			})).orElse(Endecs.VAR_INT.xmap((int ordinal) => enumValues.GetValue(ordinal) as E, (E value) => entryToIndex[value]));
		}

		public static StructEndec<T> dispatchedStruct<T, K>(Func<K, StructEndec<T>> variantToEndec, Func<T, K> instanceToVariant, Endec<K> variantEndec)
		{
			return dispatchedStruct(variantToEndec, instanceToVariant, variantEndec, "type");
		}

		public static StructEndec<T> dispatchedStruct<T, K>(Func<K, StructEndec<T>> variantToEndec, Func<T, K> instanceToVariant, Endec<K> variantEndec, string variantKey)
		{
			Func<T, K> instanceToVariant2 = instanceToVariant;
			string variantKey2 = variantKey;
			Endec<K> variantEndec2 = variantEndec;
			Func<K, StructEndec<T>> variantToEndec2 = variantToEndec;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, T value)
			{
				K val = instanceToVariant2(value);
				instance.field(variantKey2, ctx, variantEndec2, val);
				variantToEndec2(val).encodeStruct(ctx, serializer, instance, value);
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance)
			{
				K arg = instance.field(variantKey2, ctx, variantEndec2);
				return variantToEndec2(arg).decodeStruct(ctx, deserializer, instance);
			});
		}

		public static StructEndec<T> dispatched<T, K>(Func<K, Endec<T>> variantToEndec, Func<T, K> instanceToVariant, Endec<K> variantEndec)
		{
			Func<T, K> instanceToVariant2 = instanceToVariant;
			Endec<K> variantEndec2 = variantEndec;
			Func<K, Endec<T>> variantToEndec2 = variantToEndec;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> _, StructSerializer instance, T value)
			{
				K val = instanceToVariant2(value);
				instance.field("variant", ctx, variantEndec2, val);
				instance.field("instance", ctx, variantToEndec2(val), value);
			}, delegate(SerializationContext ctx, Deserializer<dynamic> _, StructDeserializer instance)
			{
				K arg = instance.field("variant", ctx, variantEndec2);
				return instance.field("instance", ctx, variantToEndec2(arg));
			});
		}

		public static StructEndec<T> dispatchedFlatable<T, K>(string variantKey, string instanceKey, Func<K, Endec<T>> variantToEndec, Func<T, K> instanceToVariant, Endec<K> variantEndec)
		{
			Func<T, K> instanceToVariant2 = instanceToVariant;
			Endec<K> variantEndec2 = variantEndec;
			Func<K, Endec<T>> variantToEndec2 = variantToEndec;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, T value)
			{
				K val = instanceToVariant2(value);
				instance.field("variant", ctx, variantEndec2, val);
				Endec<T> endec2 = variantToEndec2(val);
				if (endec2 is StructEndec<T> structEndec2)
				{
					structEndec2.encodeStruct(ctx, serializer, instance, value);
				}
				else
				{
					instance.field("instance", ctx, endec2, value);
				}
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance)
			{
				K arg = instance.field("variant", ctx, variantEndec2);
				Endec<T> endec = variantToEndec2(arg);
				return (T)((endec is StructEndec<T> structEndec) ? ((object)structEndec.decodeStruct(ctx, deserializer, instance)) : ((object)instance.field("instance", ctx, endec)));
			});
		}

		public static AttributeEndecBuilder<T> ifAttr<T>(SerializationAttribute attribute, Endec<T> endec)
		{
			return new AttributeEndecBuilder<T>(endec, attribute);
		}
	}
	public static class DictionaryExtensions
	{
		public static IDictionary<TKey, TValue> ImmutableWrap<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
		{
			return new ReadOnlyDictionary<TKey, TValue>(dictionary);
		}

		public static void AddAll<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, IDictionary<TKey, TValue> additional)
		{
			foreach (KeyValuePair<TKey, TValue> item in additional)
			{
				dictionary.Add(item);
			}
		}

		public static void AddAll<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, IEnumerable<KeyValuePair<TKey, TValue>> additional)
		{
			foreach (KeyValuePair<TKey, TValue> item in additional)
			{
				dictionary.Add(item);
			}
		}
	}
	public static class SetExtensions
	{
		public static ISet<T> ImmutableWrap<T>(this ISet<T> set)
		{
			return new ReadOnlySet<T>(set);
		}

		public static void AddAll<T>(this ISet<T> set, IEnumerable<T> additional)
		{
			set.UnionWith(additional);
		}
	}
	public static class EnumerableExtensions
	{
		public static ISet<T> ImmutableSet<T>(this IEnumerable<T> set)
		{
			return new ReadOnlySet<T>(set);
		}
	}
	public interface MapCarrier
	{
		T getWithErrors<T>(SerializationContext ctx, KeyedEndec<T> key);

		T getWithErrors<T>(KeyedEndec<T> key)
		{
			return getWithErrors(SerializationContext.empty(), key);
		}

		void put<T>(SerializationContext ctx, KeyedEndec<T> key, T value);

		void put<T>(KeyedEndec<T> key, T value)
		{
			put(SerializationContext.empty(), key, value);
		}

		void delete<T>(KeyedEndec<T> key);

		bool has<T>(KeyedEndec<T> key);

		T get<T>(SerializationContext ctx, KeyedEndec<T> key)
		{
			try
			{
				return getWithErrors(ctx, key);
			}
			catch (Exception)
			{
				return key.defaultValue();
			}
		}

		T get<T>(KeyedEndec<T> key)
		{
			return get(SerializationContext.empty(), key);
		}

		void putIfNotNull<T>(KeyedEndec<T> key, T? value)
		{
			putIfNotNull(SerializationContext.empty(), key, value);
		}

		void putIfNotNull<T>(SerializationContext ctx, KeyedEndec<T> key, T? value)
		{
			if (value != null)
			{
				put(ctx, key, value);
			}
		}

		void copy<T>(KeyedEndec<T> key, MapCarrier other)
		{
			copy(SerializationContext.empty(), key, other);
		}

		void copy<T>(SerializationContext ctx, KeyedEndec<T> key, MapCarrier other)
		{
			other.put(ctx, key, get(ctx, key));
		}

		void copyIfPresent<T>(KeyedEndec<T> key, MapCarrier other)
		{
			copyIfPresent(SerializationContext.empty(), key, other);
		}

		void copyIfPresent<T>(SerializationContext ctx, KeyedEndec<T> key, MapCarrier other)
		{
			if (has(key))
			{
				copy(ctx, key, other);
			}
		}

		void mutate<T>(KeyedEndec<T> key, Func<T, T> mutator)
		{
			mutate(SerializationContext.empty(), key, mutator);
		}

		void mutate<T>(SerializationContext ctx, KeyedEndec<T> key, Func<T, T> mutator)
		{
			put(ctx, key, mutator(get(ctx, key)));
		}
	}
	public class ReadOnlySet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable
	{
		private readonly ISet<T> _set;

		public int Count => _set.Count;

		public bool IsReadOnly => true;

		public ReadOnlySet(ISet<T> set)
		{
			_set = set;
		}

		public ReadOnlySet(IEnumerable<T> enumerable)
		{
			_set = new HashSet<T>(enumerable);
		}

		public ReadOnlySet(params T[] entries)
		{
			_set = new HashSet<T>(entries);
		}

		public void Add(T item)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public void ExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public void IntersectWith(IEnumerable<T> other)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			return _set.IsProperSubsetOf(other);
		}

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			return _set.IsProperSupersetOf(other);
		}

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			return _set.IsSubsetOf(other);
		}

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			return _set.IsSupersetOf(other);
		}

		public bool Overlaps(IEnumerable<T> other)
		{
			return _set.Overlaps(other);
		}

		public bool SetEquals(IEnumerable<T> other)
		{
			return _set.SetEquals(other);
		}

		public void SymmetricExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public void UnionWith(IEnumerable<T> other)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		bool ISet<T>.Add(T item)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public void Clear()
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public bool Contains(T item)
		{
			return _set.Contains(item);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			_set.CopyTo(array, arrayIndex);
		}

		public bool Remove(T item)
		{
			throw new NotSupportedException("Adding an item is not supported due to being read-only.");
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _set.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public abstract class RecursiveDeserializer<T> : Deserializer<T> where T : class
	{
		private readonly LinkedList<Func<T>> frames = new LinkedList<Func<T>>();

		private readonly T serialized;

		protected RecursiveDeserializer(T serialized)
		{
			this.serialized = serialized;
			frames.AddFirst(() => this.serialized);
		}

		protected T getValue()
		{
			return frames.First.Value();
		}

		protected V frame<V>(Func<T> nextValue, Func<V> action)
		{
			try
			{
				frames.AddFirst(nextValue);
				return action();
			}
			finally
			{
				frames.RemoveFirst();
			}
		}

		public V tryRead<V>(Func<Deserializer<T>, V> reader)
		{
			LinkedList<Func<T>> linkedList = new LinkedList<Func<T>>(frames);
			try
			{
				return reader(this);
			}
			catch (Exception ex)
			{
				frames.Clear();
				foreach (Func<T> item in linkedList)
				{
					frames.AddFirst(item);
				}
				throw ex;
			}
		}

		public abstract byte readByte(SerializationContext ctx);

		public abstract short readShort(SerializationContext ctx);

		public abstract int readInt(SerializationContext ctx);

		public abstract long readLong(SerializationContext ctx);

		public abstract float readFloat(SerializationContext ctx);

		public abstract double readDouble(SerializationContext ctx);

		public abstract int readVarInt(SerializationContext ctx);

		public abstract long readVarLong(SerializationContext ctx);

		public abstract bool readBoolean(SerializationContext ctx);

		public abstract string readString(SerializationContext ctx);

		public abstract byte[] readBytes(SerializationContext ctx);

		public abstract V? readOptional<V>(SerializationContext ctx, Endec<V> endec);

		public abstract SequenceDeserializer<E> sequence<E>(SerializationContext ctx, Endec<E> elementEndec);

		public abstract MapDeserializer<V> map<V>(SerializationContext ctx, Endec<V> valueEndec);

		public abstract StructDeserializer structed();
	}
	public abstract class RecursiveSerializer<T> : Serializer<T> where T : class
	{
		private readonly LinkedList<Action<T>> _frames = new LinkedList<Action<T>>();

		private T _result;

		protected RecursiveSerializer(T initialResult)
		{
			_result = initialResult;
			_frames.AddFirst(delegate(T t)
			{
				_result = t;
			});
		}

		protected void consume(T value)
		{
			_frames.First.Value(value);
		}

		protected void frame(FrameAction<T> action)
		{
			EncodedValue<T> encodedValue = new EncodedValue<T>();
			_frames.AddFirst(encodedValue.set);
			action(encodedValue);
			_frames.RemoveFirst();
		}

		public T result()
		{
			return _result;
		}

		public abstract void writeByte(SerializationContext ctx, byte value);

		public abstract void writeShort(SerializationContext ctx, short value);

		public abstract void writeInt(SerializationContext ctx, int value);

		public abstract void writeLong(SerializationContext ctx, long value);

		public abstract void writeFloat(SerializationContext ctx, float value);

		public abstract void writeDouble(SerializationContext ctx, double value);

		public abstract void writeVarInt(SerializationContext ctx, int value);

		public abstract void writeVarLong(SerializationContext ctx, long value);

		public abstract void writeBoolean(SerializationContext ctx, bool value);

		public abstract void writeString(SerializationContext ctx, string value);

		public abstract void writeBytes(SerializationContext ctx, byte[] bytes);

		public abstract void writeOptional<V>(SerializationContext ctx, Endec<V> endec, V? optional);

		public abstract SequenceSerializer<E> sequence<E>(SerializationContext ctx, Endec<E> elementEndec, int size);

		public abstract MapSerializer<V> map<V>(SerializationContext ctx, Endec<V> valueEndec, int size);

		public abstract StructSerializer structed();
	}
	public delegate void FrameAction<T>(EncodedValue<T> encoded);
	public class EncodedValue<T>
	{
		private T? _value = default(T);

		private bool _encoded = false;

		internal void set(T value)
		{
			_value = value;
			_encoded = true;
		}

		public T value()
		{
			return _value;
		}

		public bool wasEncoded()
		{
			return _encoded;
		}

		public T require(string name)
		{
			if (!_encoded)
			{
				throw new Exception("Endec for " + name + " serialized nothing");
			}
			return value();
		}
	}
	public class VarInts
	{
		public const int SEGMENT_BITS = 127;

		public const int CONTINUE_BIT = 128;

		public static int getSizeInBytesFromInt(int i)
		{
			for (int j = 1; j < 5; j++)
			{
				if ((i & (-1 << j * 7)) == 0)
				{
					return j;
				}
			}
			return 5;
		}

		public static int getSizeInBytesFromLong(long l)
		{
			for (int i = 1; i < 10; i++)
			{
				if ((l & (-1L << i * 7)) == 0)
				{
					return i;
				}
			}
			return 10;
		}

		public static int readInt(Func<byte> readByteSup)
		{
			int num = 0;
			int num2 = 0;
			while (true)
			{
				byte b = readByteSup();
				num |= (b & 0x7F) << num2;
				if ((b & 0x80) == 0)
				{
					break;
				}
				num2 += 7;
				if (num2 >= 32)
				{
					throw new Exception("VarInt is too big");
				}
			}
			return num;
		}

		public static void writeInt(int value, Action<byte> writeByteFunc)
		{
			while (((uint)value & 0xFFFFFF80u) != 0)
			{
				writeByteFunc((byte)(((uint)value & 0x7Fu) | 0x80u));
				value >>>= 7;
			}
			writeByteFunc((byte)value);
		}

		public static long readLong(Func<byte> readByteSup)
		{
			long num = 0L;
			int num2 = 0;
			while (true)
			{
				byte b = readByteSup();
				num |= (long)(b & 0x7F) << num2;
				if ((b & 0x80) == 0)
				{
					break;
				}
				num2 += 7;
				if (num2 >= 64)
				{
					throw new Exception("VarLong is too big");
				}
			}
			return num;
		}

		public static void writeLong(long value, Action<byte> writeByteFunc)
		{
			while ((value & -128) != 0)
			{
				writeByteFunc((byte)((value & 0x7F) | 0x80));
				value >>>= 7;
			}
			writeByteFunc((byte)value);
		}
	}
}
namespace io.wispforest.impl
{
	public class AttributeEndecBuilder<T>
	{
		private readonly List<(SerializationAttribute, Endec<T>)> _branches = new List<(SerializationAttribute, Endec<T>)>();

		public AttributeEndecBuilder(Endec<T> endec, SerializationAttribute attribute)
		{
			_branches.Add((attribute, endec));
		}

		public AttributeEndecBuilder<T> orElseIf(Endec<T> endec, SerializationAttribute attribute)
		{
			return orElseIf(attribute, endec);
		}

		public AttributeEndecBuilder<T> orElseIf(SerializationAttribute attribute, Endec<T> endec)
		{
			SerializationAttribute attribute2 = attribute;
			if (_branches.Exists(((SerializationAttribute, Endec<T>) tuple) => tuple.Item1.Equals(attribute2)))
			{
				throw new ArgumentException("Cannot have more than one branch for attribute " + attribute2.name);
			}
			_branches.Add((attribute2, endec));
			return this;
		}

		public Endec<T> orElse(Endec<T> endec)
		{
			Endec<T> endec2 = endec;
			return EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, T value)
			{
				Endec<T> endec4 = endec2;
				foreach (var branch in _branches)
				{
					if (ctx.hasAttribute(branch.Item1))
					{
						endec4 = branch.Item2;
						break;
					}
				}
				endec4.encode(ctx, serializer, value);
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer)
			{
				Endec<T> endec3 = endec2;
				foreach (var branch2 in _branches)
				{
					if (ctx.hasAttribute(branch2.Item1))
					{
						endec3 = branch2.Item2;
						break;
					}
				}
				return endec3.decode(ctx, deserializer);
			});
		}
	}
	public class AttributeStructEndecBuilder<T>
	{
		private readonly List<(SerializationAttribute, StructEndec<T>)> branches = new List<(SerializationAttribute, StructEndec<T>)>();

		public AttributeStructEndecBuilder(StructEndec<T> endec, SerializationAttribute attribute)
		{
			branches.Add((attribute, endec));
		}

		public AttributeStructEndecBuilder<T> orElseIf(StructEndec<T> endec, SerializationAttribute attribute)
		{
			return orElseIf(attribute, endec);
		}

		public AttributeStructEndecBuilder<T> orElseIf(SerializationAttribute attribute, StructEndec<T> endec)
		{
			SerializationAttribute attribute2 = attribute;
			if (branches.Exists(((SerializationAttribute, StructEndec<T>) tuple) => tuple.Item1.Equals(attribute2)))
			{
				throw new ArgumentException("Cannot have more than one branch for attribute " + attribute2.name);
			}
			branches.Add((attribute2, endec));
			return this;
		}

		public StructEndec<T> orElse(StructEndec<T> endec)
		{
			StructEndec<T> endec2 = endec;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, T value)
			{
				StructEndec<T> structEndec2 = endec2;
				foreach (var branch in branches)
				{
					if (ctx.hasAttribute(branch.Item1))
					{
						structEndec2 = branch.Item2;
						break;
					}
				}
				structEndec2.encodeStruct(ctx, serializer, instance, value);
			}, delegate(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance)
			{
				StructEndec<T> structEndec = endec2;
				foreach (var branch2 in branches)
				{
					if (ctx.hasAttribute(branch2.Item1))
					{
						structEndec = branch2.Item2;
						break;
					}
				}
				return structEndec.decodeStruct(ctx, deserializer, instance);
			});
		}
	}
	public class EndecImpl<T> : Endec<T>
	{
		private readonly Encoder<T> _encoder;

		private readonly Decoder<T> _decoder;

		public EndecImpl(Encoder<T> encoder, Decoder<T> decoder)
		{
			_encoder = encoder;
			_decoder = decoder;
		}

		public override void encode<E>(SerializationContext ctx, Serializer<E> serializer, T value)
		{
			_encoder(ctx, serializer, value);
		}

		public override T decode<E>(SerializationContext ctx, Deserializer<E> deserializer)
		{
			return _decoder(ctx, deserializer);
		}
	}
	public class Endecs
	{
		public static readonly StructEndec<object> VOID = EndecUtils.unit<object>(null);

		public static readonly Endec<bool> BOOLEAN = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, bool value)
		{
			serializer.writeBoolean(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readBoolean(ctx));

		public static readonly Endec<byte> BYTE = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, byte value)
		{
			serializer.writeByte(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readByte(ctx));

		public static readonly Endec<short> SHORT = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, short value)
		{
			serializer.writeShort(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readShort(ctx));

		public static readonly Endec<int> INT = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, int value)
		{
			serializer.writeInt(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readInt(ctx));

		public static readonly Endec<int> VAR_INT = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, int value)
		{
			serializer.writeVarInt(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readVarInt(ctx));

		public static readonly Endec<long> LONG = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, long value)
		{
			serializer.writeLong(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readLong(ctx));

		public static readonly Endec<long> VAR_LONG = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, long value)
		{
			serializer.writeVarLong(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readVarLong(ctx));

		public static readonly Endec<float> FLOAT = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, float value)
		{
			serializer.writeFloat(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readFloat(ctx));

		public static readonly Endec<double> DOUBLE = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, double value)
		{
			serializer.writeDouble(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readDouble(ctx));

		public static readonly Endec<string> STRING = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, string value)
		{
			serializer.writeString(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readString(ctx));

		public static readonly Endec<byte[]> BYTES = EndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, byte[] value)
		{
			serializer.writeBytes(ctx, value);
		}, (SerializationContext ctx, Deserializer<dynamic> deserializer) => deserializer.readBytes(ctx));

		public static readonly Endec<int[]> INT_ARRAY = INT.listOf().xmap((IList<int> list) => list.ToArray(), (int[] ints) => new List<int>(ints));

		public static readonly Endec<long[]> LONG_ARRAY = LONG.listOf().xmap((IList<long> list) => list.ToArray(), (long[] longs) => new List<long>(longs));

		public static readonly Endec<Guid> GUID = EndecUtils.ifAttr(SerializationAttributes.HUMAN_READABLE, STRING.xmap(Guid.Parse, (Guid guid) => guid.ToString())).orElse(BYTES.xmap((byte[] bytes) => new Guid(bytes), (Guid guid) => guid.ToByteArray()));

		public static Endec<V> vectorEndec<C, V>(string name, Endec<C> componentEndec, Func<C, C, V> constructor, Func<V, C> xGetter, Func<V, C> yGetter)
		{
			Func<C, C, V> constructor2 = constructor;
			Func<V, C> xGetter2 = xGetter;
			Func<V, C> yGetter2 = yGetter;
			return componentEndec.listOf().validate(validateSize<C>(name, 2)).xmap((IList<C> components) => constructor2(components[0], components[1]), (V vector) => new List<C>(2)
			{
				xGetter2(vector),
				yGetter2(vector)
			});
		}

		public static Endec<V> vectorEndec<C, V>(string name, Endec<C> componentEndec, Func<C, C, C, V> constructor, Func<V, C> xGetter, Func<V, C> yGetter, Func<V, C> zGetter)
		{
			Func<C, C, C, V> constructor2 = constructor;
			Func<V, C> xGetter2 = xGetter;
			Func<V, C> yGetter2 = yGetter;
			Func<V, C> zGetter2 = zGetter;
			return componentEndec.listOf().validate(validateSize<C>(name, 3)).xmap((IList<C> components) => constructor2(components[0], components[1], components[2]), (V vector) => new List<C>(3)
			{
				xGetter2(vector),
				yGetter2(vector),
				zGetter2(vector)
			});
		}

		public static Endec<V> vectorEndec<C, V>(string name, Endec<C> componentEndec, Func<C, C, C, C, V> constructor, Func<V, C> xGetter, Func<V, C> yGetter, Func<V, C> zGetter, Func<V, C> wGetter)
		{
			Func<C, C, C, C, V> constructor2 = constructor;
			Func<V, C> xGetter2 = xGetter;
			Func<V, C> yGetter2 = yGetter;
			Func<V, C> zGetter2 = zGetter;
			Func<V, C> wGetter2 = wGetter;
			return componentEndec.listOf().validate(validateSize<C>(name, 4)).xmap((IList<C> components) => constructor2(components[0], components[1], components[2], components[3]), (V vector) => new List<C>(4)
			{
				xGetter2(vector),
				yGetter2(vector),
				zGetter2(vector),
				wGetter2(vector)
			});
		}

		private static Action<IList<C>> validateSize<C>(string name, int requiredSize)
		{
			string name2 = name;
			return delegate(IList<C> collection)
			{
				if (collection.Count() != 4)
				{
					throw new ArgumentException(name2 + "collection must have " + requiredSize + " elements");
				}
			};
		}
	}
	public class KeyedEndec<F>
	{
		public string key { get; }

		public Endec<F> endec { get; }

		public Func<F> defaultValueFactory { get; }

		public KeyedEndec(string key, Endec<F> endec, Func<F> defaultValueFactory)
		{
			this.key = key;
			this.endec = endec;
			this.defaultValueFactory = defaultValueFactory;
		}

		public KeyedEndec(string key, Endec<F> endec, F defaultValue)
		{
			F defaultValue2 = defaultValue;
			this..ctor(key, endec, (Func<F>)(() => defaultValue2));
		}

		public F defaultValue()
		{
			return defaultValueFactory();
		}
	}
	public class MissingAttributeValueException : Exception
	{
		public MissingAttributeValueException(string message)
			: base(message)
		{
		}
	}
	public class RecursiveEndec<T> : Endec<T>
	{
		public readonly Endec<T> endec;

		public RecursiveEndec(Func<Endec<T>, Endec<T>> builder)
		{
			endec = builder(this);
		}

		public override void encode<E>(SerializationContext ctx, Serializer<E> serializer, T value)
		{
			endec.encode(ctx, serializer, value);
		}

		public override T decode<E>(SerializationContext ctx, Deserializer<E> deserializer)
		{
			return endec.decode(ctx, deserializer);
		}
	}
	public class RecursiveStructEndec<T> : StructEndec<T>
	{
		public readonly StructEndec<T> structEndec;

		public RecursiveStructEndec(Func<StructEndec<T>, StructEndec<T>> builder)
		{
			structEndec = builder(this);
		}

		public override void encodeStruct<E>(SerializationContext ctx, Serializer<E> serializer, StructSerializer instance, T value)
		{
			structEndec.encodeStruct(ctx, serializer, instance, value);
		}

		public override T decodeStruct<E>(SerializationContext ctx, Deserializer<E> deserializer, StructDeserializer instance)
		{
			return structEndec.decodeStruct(ctx, deserializer, instance);
		}
	}
	public class StructEndecBuilder
	{
		public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, in T17, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17);

		public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, in T17, in T18, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16, T17 arg17, T18 arg18);

		public static StructEndec<S> of<S, F1>(StructField<S, F1> f1, Func<F1, S> constructor)
		{
			StructField<S, F1> f2 = f1;
			Func<F1, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f2.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f2.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2>(StructField<S, F1> f1, StructField<S, F2> f2, Func<F1, F2, S> constructor)
		{
			StructField<S, F1> f3 = f1;
			StructField<S, F2> f4 = f2;
			Func<F1, F2, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f3.encodeField(ctx, serializer, instance, value);
				f4.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f3.decodeField(ctx, deserializer, instance), f4.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, Func<F1, F2, F3, S> constructor)
		{
			StructField<S, F1> f4 = f1;
			StructField<S, F2> f5 = f2;
			StructField<S, F3> f6 = f3;
			Func<F1, F2, F3, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f4.encodeField(ctx, serializer, instance, value);
				f5.encodeField(ctx, serializer, instance, value);
				f6.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f4.decodeField(ctx, deserializer, instance), f5.decodeField(ctx, deserializer, instance), f6.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, Func<F1, F2, F3, F4, S> constructor)
		{
			StructField<S, F1> f5 = f1;
			StructField<S, F2> f6 = f2;
			StructField<S, F3> f7 = f3;
			StructField<S, F4> f8 = f4;
			Func<F1, F2, F3, F4, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f5.encodeField(ctx, serializer, instance, value);
				f6.encodeField(ctx, serializer, instance, value);
				f7.encodeField(ctx, serializer, instance, value);
				f8.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f5.decodeField(ctx, deserializer, instance), f6.decodeField(ctx, deserializer, instance), f7.decodeField(ctx, deserializer, instance), f8.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, Func<F1, F2, F3, F4, F5, S> constructor)
		{
			StructField<S, F1> f6 = f1;
			StructField<S, F2> f7 = f2;
			StructField<S, F3> f8 = f3;
			StructField<S, F4> f9 = f4;
			StructField<S, F5> f10 = f5;
			Func<F1, F2, F3, F4, F5, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f6.encodeField(ctx, serializer, instance, value);
				f7.encodeField(ctx, serializer, instance, value);
				f8.encodeField(ctx, serializer, instance, value);
				f9.encodeField(ctx, serializer, instance, value);
				f10.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f6.decodeField(ctx, deserializer, instance), f7.decodeField(ctx, deserializer, instance), f8.decodeField(ctx, deserializer, instance), f9.decodeField(ctx, deserializer, instance), f10.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, Func<F1, F2, F3, F4, F5, F6, S> constructor)
		{
			StructField<S, F1> f7 = f1;
			StructField<S, F2> f8 = f2;
			StructField<S, F3> f9 = f3;
			StructField<S, F4> f10 = f4;
			StructField<S, F5> f11 = f5;
			StructField<S, F6> f12 = f6;
			Func<F1, F2, F3, F4, F5, F6, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f7.encodeField(ctx, serializer, instance, value);
				f8.encodeField(ctx, serializer, instance, value);
				f9.encodeField(ctx, serializer, instance, value);
				f10.encodeField(ctx, serializer, instance, value);
				f11.encodeField(ctx, serializer, instance, value);
				f12.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f7.decodeField(ctx, deserializer, instance), f8.decodeField(ctx, deserializer, instance), f9.decodeField(ctx, deserializer, instance), f10.decodeField(ctx, deserializer, instance), f11.decodeField(ctx, deserializer, instance), f12.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, Func<F1, F2, F3, F4, F5, F6, F7, S> constructor)
		{
			StructField<S, F1> f8 = f1;
			StructField<S, F2> f9 = f2;
			StructField<S, F3> f10 = f3;
			StructField<S, F4> f11 = f4;
			StructField<S, F5> f12 = f5;
			StructField<S, F6> f13 = f6;
			StructField<S, F7> f14 = f7;
			Func<F1, F2, F3, F4, F5, F6, F7, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f8.encodeField(ctx, serializer, instance, value);
				f9.encodeField(ctx, serializer, instance, value);
				f10.encodeField(ctx, serializer, instance, value);
				f11.encodeField(ctx, serializer, instance, value);
				f12.encodeField(ctx, serializer, instance, value);
				f13.encodeField(ctx, serializer, instance, value);
				f14.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f8.decodeField(ctx, deserializer, instance), f9.decodeField(ctx, deserializer, instance), f10.decodeField(ctx, deserializer, instance), f11.decodeField(ctx, deserializer, instance), f12.decodeField(ctx, deserializer, instance), f13.decodeField(ctx, deserializer, instance), f14.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, Func<F1, F2, F3, F4, F5, F6, F7, F8, S> constructor)
		{
			StructField<S, F1> f9 = f1;
			StructField<S, F2> f10 = f2;
			StructField<S, F3> f11 = f3;
			StructField<S, F4> f12 = f4;
			StructField<S, F5> f13 = f5;
			StructField<S, F6> f14 = f6;
			StructField<S, F7> f15 = f7;
			StructField<S, F8> f16 = f8;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f9.encodeField(ctx, serializer, instance, value);
				f10.encodeField(ctx, serializer, instance, value);
				f11.encodeField(ctx, serializer, instance, value);
				f12.encodeField(ctx, serializer, instance, value);
				f13.encodeField(ctx, serializer, instance, value);
				f14.encodeField(ctx, serializer, instance, value);
				f15.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f9.decodeField(ctx, deserializer, instance), f10.decodeField(ctx, deserializer, instance), f11.decodeField(ctx, deserializer, instance), f12.decodeField(ctx, deserializer, instance), f13.decodeField(ctx, deserializer, instance), f14.decodeField(ctx, deserializer, instance), f15.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, S> constructor)
		{
			StructField<S, F1> f10 = f1;
			StructField<S, F2> f11 = f2;
			StructField<S, F3> f12 = f3;
			StructField<S, F4> f13 = f4;
			StructField<S, F5> f14 = f5;
			StructField<S, F6> f15 = f6;
			StructField<S, F7> f16 = f7;
			StructField<S, F8> f17 = f8;
			StructField<S, F9> f18 = f9;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f10.encodeField(ctx, serializer, instance, value);
				f11.encodeField(ctx, serializer, instance, value);
				f12.encodeField(ctx, serializer, instance, value);
				f13.encodeField(ctx, serializer, instance, value);
				f14.encodeField(ctx, serializer, instance, value);
				f15.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f10.decodeField(ctx, deserializer, instance), f11.decodeField(ctx, deserializer, instance), f12.decodeField(ctx, deserializer, instance), f13.decodeField(ctx, deserializer, instance), f14.decodeField(ctx, deserializer, instance), f15.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, S> constructor)
		{
			StructField<S, F1> f11 = f1;
			StructField<S, F2> f13 = f2;
			StructField<S, F3> f14 = f3;
			StructField<S, F4> f15 = f4;
			StructField<S, F5> f16 = f5;
			StructField<S, F6> f17 = f6;
			StructField<S, F7> f18 = f7;
			StructField<S, F8> f19 = f8;
			StructField<S, F9> f20 = f9;
			StructField<S, F10> f12 = f10;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f11.encodeField(ctx, serializer, instance, value);
				f13.encodeField(ctx, serializer, instance, value);
				f14.encodeField(ctx, serializer, instance, value);
				f15.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f12.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f11.decodeField(ctx, deserializer, instance), f13.decodeField(ctx, deserializer, instance), f14.decodeField(ctx, deserializer, instance), f15.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f12.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, S> constructor)
		{
			StructField<S, F1> f12 = f1;
			StructField<S, F2> f15 = f2;
			StructField<S, F3> f16 = f3;
			StructField<S, F4> f17 = f4;
			StructField<S, F5> f18 = f5;
			StructField<S, F6> f19 = f6;
			StructField<S, F7> f20 = f7;
			StructField<S, F8> f21 = f8;
			StructField<S, F9> f22 = f9;
			StructField<S, F10> f13 = f10;
			StructField<S, F11> f14 = f11;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f12.encodeField(ctx, serializer, instance, value);
				f15.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f13.encodeField(ctx, serializer, instance, value);
				f14.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f12.decodeField(ctx, deserializer, instance), f15.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f13.decodeField(ctx, deserializer, instance), f14.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, S> constructor)
		{
			StructField<S, F1> f13 = f1;
			StructField<S, F2> f17 = f2;
			StructField<S, F3> f18 = f3;
			StructField<S, F4> f19 = f4;
			StructField<S, F5> f20 = f5;
			StructField<S, F6> f21 = f6;
			StructField<S, F7> f22 = f7;
			StructField<S, F8> f23 = f8;
			StructField<S, F9> f24 = f9;
			StructField<S, F10> f14 = f10;
			StructField<S, F11> f15 = f11;
			StructField<S, F12> f16 = f12;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f13.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
				f14.encodeField(ctx, serializer, instance, value);
				f15.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f13.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance), f14.decodeField(ctx, deserializer, instance), f15.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, StructField<S, F13> f13, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, S> constructor)
		{
			StructField<S, F1> f14 = f1;
			StructField<S, F2> f19 = f2;
			StructField<S, F3> f20 = f3;
			StructField<S, F4> f21 = f4;
			StructField<S, F5> f22 = f5;
			StructField<S, F6> f23 = f6;
			StructField<S, F7> f24 = f7;
			StructField<S, F8> f25 = f8;
			StructField<S, F9> f26 = f9;
			StructField<S, F10> f15 = f10;
			StructField<S, F11> f16 = f11;
			StructField<S, F12> f17 = f12;
			StructField<S, F13> f18 = f13;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f14.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
				f25.encodeField(ctx, serializer, instance, value);
				f26.encodeField(ctx, serializer, instance, value);
				f15.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f14.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance), f25.decodeField(ctx, deserializer, instance), f26.decodeField(ctx, deserializer, instance), f15.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, StructField<S, F13> f13, StructField<S, F14> f14, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, S> constructor)
		{
			StructField<S, F1> f15 = f1;
			StructField<S, F2> f21 = f2;
			StructField<S, F3> f22 = f3;
			StructField<S, F4> f23 = f4;
			StructField<S, F5> f24 = f5;
			StructField<S, F6> f25 = f6;
			StructField<S, F7> f26 = f7;
			StructField<S, F8> f27 = f8;
			StructField<S, F9> f28 = f9;
			StructField<S, F10> f16 = f10;
			StructField<S, F11> f17 = f11;
			StructField<S, F12> f18 = f12;
			StructField<S, F13> f19 = f13;
			StructField<S, F14> f20 = f14;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f15.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
				f25.encodeField(ctx, serializer, instance, value);
				f26.encodeField(ctx, serializer, instance, value);
				f27.encodeField(ctx, serializer, instance, value);
				f28.encodeField(ctx, serializer, instance, value);
				f16.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f15.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance), f25.decodeField(ctx, deserializer, instance), f26.decodeField(ctx, deserializer, instance), f27.decodeField(ctx, deserializer, instance), f28.decodeField(ctx, deserializer, instance), f16.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, StructField<S, F13> f13, StructField<S, F14> f14, StructField<S, F15> f15, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, S> constructor)
		{
			StructField<S, F1> f16 = f1;
			StructField<S, F2> f23 = f2;
			StructField<S, F3> f24 = f3;
			StructField<S, F4> f25 = f4;
			StructField<S, F5> f26 = f5;
			StructField<S, F6> f27 = f6;
			StructField<S, F7> f28 = f7;
			StructField<S, F8> f29 = f8;
			StructField<S, F9> f30 = f9;
			StructField<S, F10> f17 = f10;
			StructField<S, F11> f18 = f11;
			StructField<S, F12> f19 = f12;
			StructField<S, F13> f20 = f13;
			StructField<S, F14> f21 = f14;
			StructField<S, F15> f22 = f15;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f16.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
				f25.encodeField(ctx, serializer, instance, value);
				f26.encodeField(ctx, serializer, instance, value);
				f27.encodeField(ctx, serializer, instance, value);
				f28.encodeField(ctx, serializer, instance, value);
				f29.encodeField(ctx, serializer, instance, value);
				f30.encodeField(ctx, serializer, instance, value);
				f17.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f16.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance), f25.decodeField(ctx, deserializer, instance), f26.decodeField(ctx, deserializer, instance), f27.decodeField(ctx, deserializer, instance), f28.decodeField(ctx, deserializer, instance), f29.decodeField(ctx, deserializer, instance), f30.decodeField(ctx, deserializer, instance), f17.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, StructField<S, F13> f13, StructField<S, F14> f14, StructField<S, F15> f15, StructField<S, F16> f16, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, S> constructor)
		{
			StructField<S, F1> f17 = f1;
			StructField<S, F2> f25 = f2;
			StructField<S, F3> f26 = f3;
			StructField<S, F4> f27 = f4;
			StructField<S, F5> f28 = f5;
			StructField<S, F6> f29 = f6;
			StructField<S, F7> f30 = f7;
			StructField<S, F8> f31 = f8;
			StructField<S, F9> f32 = f9;
			StructField<S, F10> f18 = f10;
			StructField<S, F11> f19 = f11;
			StructField<S, F12> f20 = f12;
			StructField<S, F13> f21 = f13;
			StructField<S, F14> f22 = f14;
			StructField<S, F15> f23 = f15;
			StructField<S, F16> f24 = f16;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f17.encodeField(ctx, serializer, instance, value);
				f25.encodeField(ctx, serializer, instance, value);
				f26.encodeField(ctx, serializer, instance, value);
				f27.encodeField(ctx, serializer, instance, value);
				f28.encodeField(ctx, serializer, instance, value);
				f29.encodeField(ctx, serializer, instance, value);
				f30.encodeField(ctx, serializer, instance, value);
				f31.encodeField(ctx, serializer, instance, value);
				f32.encodeField(ctx, serializer, instance, value);
				f18.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f17.decodeField(ctx, deserializer, instance), f25.decodeField(ctx, deserializer, instance), f26.decodeField(ctx, deserializer, instance), f27.decodeField(ctx, deserializer, instance), f28.decodeField(ctx, deserializer, instance), f29.decodeField(ctx, deserializer, instance), f30.decodeField(ctx, deserializer, instance), f31.decodeField(ctx, deserializer, instance), f32.decodeField(ctx, deserializer, instance), f18.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, StructField<S, F13> f13, StructField<S, F14> f14, StructField<S, F15> f15, StructField<S, F16> f16, StructField<S, F17> f17, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, S> constructor)
		{
			StructField<S, F1> f18 = f1;
			StructField<S, F2> f27 = f2;
			StructField<S, F3> f28 = f3;
			StructField<S, F4> f29 = f4;
			StructField<S, F5> f30 = f5;
			StructField<S, F6> f31 = f6;
			StructField<S, F7> f32 = f7;
			StructField<S, F8> f33 = f8;
			StructField<S, F9> f34 = f9;
			StructField<S, F10> f19 = f10;
			StructField<S, F11> f20 = f11;
			StructField<S, F12> f21 = f12;
			StructField<S, F13> f22 = f13;
			StructField<S, F14> f23 = f14;
			StructField<S, F15> f24 = f15;
			StructField<S, F16> f25 = f16;
			StructField<S, F17> f26 = f17;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f18.encodeField(ctx, serializer, instance, value);
				f27.encodeField(ctx, serializer, instance, value);
				f28.encodeField(ctx, serializer, instance, value);
				f29.encodeField(ctx, serializer, instance, value);
				f30.encodeField(ctx, serializer, instance, value);
				f31.encodeField(ctx, serializer, instance, value);
				f32.encodeField(ctx, serializer, instance, value);
				f33.encodeField(ctx, serializer, instance, value);
				f34.encodeField(ctx, serializer, instance, value);
				f19.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
				f25.encodeField(ctx, serializer, instance, value);
				f26.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f18.decodeField(ctx, deserializer, instance), f27.decodeField(ctx, deserializer, instance), f28.decodeField(ctx, deserializer, instance), f29.decodeField(ctx, deserializer, instance), f30.decodeField(ctx, deserializer, instance), f31.decodeField(ctx, deserializer, instance), f32.decodeField(ctx, deserializer, instance), f33.decodeField(ctx, deserializer, instance), f34.decodeField(ctx, deserializer, instance), f19.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance), f25.decodeField(ctx, deserializer, instance), f26.decodeField(ctx, deserializer, instance)));
		}

		public static StructEndec<S> of<S, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18>(StructField<S, F1> f1, StructField<S, F2> f2, StructField<S, F3> f3, StructField<S, F4> f4, StructField<S, F5> f5, StructField<S, F6> f6, StructField<S, F7> f7, StructField<S, F8> f8, StructField<S, F9> f9, StructField<S, F10> f10, StructField<S, F11> f11, StructField<S, F12> f12, StructField<S, F13> f13, StructField<S, F14> f14, StructField<S, F15> f15, StructField<S, F16> f16, StructField<S, F17> f17, StructField<S, F18> f18, Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, S> constructor)
		{
			StructField<S, F1> f19 = f1;
			StructField<S, F2> f29 = f2;
			StructField<S, F3> f30 = f3;
			StructField<S, F4> f31 = f4;
			StructField<S, F5> f32 = f5;
			StructField<S, F6> f33 = f6;
			StructField<S, F7> f34 = f7;
			StructField<S, F8> f35 = f8;
			StructField<S, F9> f36 = f9;
			StructField<S, F10> f20 = f10;
			StructField<S, F11> f21 = f11;
			StructField<S, F12> f22 = f12;
			StructField<S, F13> f23 = f13;
			StructField<S, F14> f24 = f14;
			StructField<S, F15> f25 = f15;
			StructField<S, F16> f26 = f16;
			StructField<S, F17> f27 = f17;
			StructField<S, F18> f28 = f18;
			Func<F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, S> constructor2 = constructor;
			return StructEndecUtils.of(delegate(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S value)
			{
				f19.encodeField(ctx, serializer, instance, value);
				f29.encodeField(ctx, serializer, instance, value);
				f30.encodeField(ctx, serializer, instance, value);
				f31.encodeField(ctx, serializer, instance, value);
				f32.encodeField(ctx, serializer, instance, value);
				f33.encodeField(ctx, serializer, instance, value);
				f34.encodeField(ctx, serializer, instance, value);
				f35.encodeField(ctx, serializer, instance, value);
				f36.encodeField(ctx, serializer, instance, value);
				f20.encodeField(ctx, serializer, instance, value);
				f21.encodeField(ctx, serializer, instance, value);
				f22.encodeField(ctx, serializer, instance, value);
				f23.encodeField(ctx, serializer, instance, value);
				f24.encodeField(ctx, serializer, instance, value);
				f25.encodeField(ctx, serializer, instance, value);
				f26.encodeField(ctx, serializer, instance, value);
				f27.encodeField(ctx, serializer, instance, value);
				f28.encodeField(ctx, serializer, instance, value);
			}, (SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance) => constructor2(f19.decodeField(ctx, deserializer, instance), f29.decodeField(ctx, deserializer, instance), f30.decodeField(ctx, deserializer, instance), f31.decodeField(ctx, deserializer, instance), f32.decodeField(ctx, deserializer, instance), f33.decodeField(ctx, deserializer, instance), f34.decodeField(ctx, deserializer, instance), f35.decodeField(ctx, deserializer, instance), f36.decodeField(ctx, deserializer, instance), f20.decodeField(ctx, deserializer, instance), f21.decodeField(ctx, deserializer, instance), f22.decodeField(ctx, deserializer, instance), f23.decodeField(ctx, deserializer, instance), f24.decodeField(ctx, deserializer, instance), f25.decodeField(ctx, deserializer, instance), f26.decodeField(ctx, deserializer, instance), f27.decodeField(ctx, deserializer, instance), f28.decodeField(ctx, deserializer, instance)));
		}
	}
	public class StructEndecImpl<T> : StructEndec<T>
	{
		private readonly StructuredEncoder<T> _encoder;

		private readonly StructuredDecoder<T> _decoder;

		public StructEndecImpl(StructuredEncoder<T> encoder, StructuredDecoder<T> decoder)
		{
			_encoder = encoder;
			_decoder = decoder;
		}

		public override void encodeStruct<E>(SerializationContext ctx, Serializer<E> serializer, StructSerializer instance, T value)
		{
			_encoder(ctx, serializer, instance, value);
		}

		public override T decodeStruct<E>(SerializationContext ctx, Deserializer<E> deserializer, StructDeserializer instance)
		{
			return _decoder(ctx, deserializer, instance);
		}
	}
	public class StructField<S, F>
	{
		protected readonly string _name;

		protected readonly Endec<F> _endec;

		protected readonly Func<S, F> _getter;

		protected readonly Func<F>? _defaultValueFactory;

		public StructField(string name, Endec<F> endec, Func<S, F> getter, Func<F> defaultValueFactory)
		{
			_name = name;
			_endec = endec;
			_getter = getter;
			_defaultValueFactory = defaultValueFactory;
		}

		public StructField(string name, Endec<F> endec, Func<S, F> getter, F? defaultValue)
		{
			F defaultValue2 = defaultValue;
			this..ctor(name, endec, getter, (Func<F>)(() => defaultValue2));
		}

		public StructField(string name, Endec<F> endec, Func<S, F> getter)
			: this(name, endec, getter, (Func<F>)null)
		{
		}

		public virtual void encodeField(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S obj)
		{
			try
			{
				instance.field(_name, ctx, _endec, _getter(obj), _defaultValueFactory != null);
			}
			catch (Exception cause)
			{
				throw new StructFieldException("Exception occurred when encoding a given StructField: [Field: " + _name + "]", cause);
			}
		}

		public virtual F decodeField(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance)
		{
			try
			{
				return instance.field(_name, ctx, _endec, _defaultValueFactory);
			}
			catch (Exception cause)
			{
				throw new StructFieldException("Exception occurred when decoding a given StructField: [Field: " + _name + "]", cause);
			}
		}
	}
	public sealed class FlatStructField<S, F> : StructField<S, F>
	{
		public FlatStructField(StructEndec<F> endec, Func<S, F> getter)
			: base("", (Endec<F>)endec, getter, (Func<F>)null)
		{
		}

		public override void encodeField(SerializationContext ctx, Serializer<dynamic> serializer, StructSerializer instance, S obj)
		{
			(_endec as StructEndec<F>).encodeStruct(ctx, serializer, instance, _getter(obj));
		}

		public override F decodeField(SerializationContext ctx, Deserializer<dynamic> deserializer, StructDeserializer instance)
		{
			return (_endec as StructEndec<F>).decodeStruct(ctx, deserializer, instance);
		}
	}
	public class StructFieldException : Exception
	{
		public StructFieldException(string message, Exception cause)
			: base(message, cause)
		{
		}
	}
}
namespace io.wispforest.format.binary
{
	public class BinaryReaderDeserializer : Deserializer<BinaryReader>
	{
		public static Action<string> DEBUG_HOOK_1 = delegate
		{
		};

		protected readonly BinaryReader input;

		protected BinaryReaderDeserializer(BinaryReader input)
		{
			this.input = input;
		}

		public static BinaryReaderDeserializer of(BinaryReader input)
		{
			return new BinaryReaderDeserializer(input);
		}

		public byte readByte(SerializationContext ctx)
		{
			return input.ReadByte();
		}

		public short readShort(SerializationContext ctx)
		{
			return input.ReadInt16();
		}

		public int readInt(SerializationContext ctx)
		{
			return input.ReadInt32();
		}

		public long readLong(SerializationContext ctx)
		{
			return input.ReadInt64();
		}

		public float readFloat(SerializationContext ctx)
		{
			return input.ReadSingle();
		}

		public double readDouble(SerializationContext ctx)
		{
			return input.ReadDouble();
		}

		public int readVarInt(SerializationContext ctx)
		{
			SerializationContext ctx2 = ctx;
			return VarInts.readInt(() => readByte(ctx2));
		}

		public long readVarLong(SerializationContext ctx)
		{
			SerializationContext ctx2 = ctx;
			return VarInts.readLong(() => readByte(ctx2));
		}

		public bool readBoolean(SerializationContext ctx)
		{
			return input.ReadBoolean();
		}

		public string readString(SerializationContext ctx)
		{
			string @string = Encoding.UTF8.GetString(readBytes(ctx));
			DEBUG_HOOK_1(@string);
			return @string;
		}

		public byte[] readBytes(SerializationContext ctx)
		{
			return input.ReadBytes(readVarInt(ctx));
		}

		public V? readOptional<V>(SerializationContext ctx, Endec<V> endec)
		{
			return (V?)(readBoolean(ctx) ? ((object)endec.decode(ctx, this)) : ((object)default(V)));
		}

		public V tryRead<V>(Func<Deserializer<BinaryReader>, V> reader)
		{
			throw new Exception("As BinaryReader cannot be rewound, tryRead(...) cannot be supported");
		}

		public SequenceDeserializer<E> sequence<E>(SerializationContext ctx, Endec<E> elementEndec)
		{
			return new BinaryReaderSequenceDeserializer<E>(this, ctx, elementEndec, readVarInt(ctx));
		}

		public MapDeserializer<V> map<V>(SerializationContext ctx, Endec<V> valueEndec)
		{
			return new BinaryReaderMapDeserializer<V>(this, ctx, valueEndec, readVarInt(ctx));
		}

		public StructDeserializer structed()
		{
			return new BinaryReaderStructDeserializer(this);
		}
	}
	internal class BinaryReaderSequenceDeserializer<V> : SequenceDeserializer<V>, IEnumerator<V>, IEnumerator, IDisposable, IEnumerable<V>, IEnumerable
	{
		private readonly BinaryReaderDeserializer deserializer;

		private readonly SerializationContext ctx;

		private readonly Endec<V> valueEndec;

		private readonly int size;

		private int index = 0;

		public V Current => next();

		public BinaryReaderSequenceDeserializer(BinaryReaderDeserializer deserializer, SerializationContext ctx, Endec<V> valueEndec, int size)
		{
			this.deserializer = deserializer;
			this.ctx = ctx;
			this.valueEndec = valueEndec;
			this.size = size;
		}

		public int estimatedSize()
		{
			return size;
		}

		public bool MoveNext()
		{
			return index < size;
		}

		public V next()
		{
			index++;
			return valueEndec.decode(ctx, deserializer);
		}

		public void Dispose()
		{
		}

		public void Reset()
		{
			throw new Exception("As BinaryReader cannot be rewound, Reset(...) cannot be supported");
		}
	}
	internal class BinaryReaderStructDeserializer : StructDeserializer
	{
		private readonly BinaryReaderDeserializer deserializer;

		public BinaryReaderStructDeserializer(BinaryReaderDeserializer deserializer)
		{
			this.deserializer = deserializer;
		}

		public T? field<T>(string name, SerializationContext ctx, Endec<T> endec, Func<T>? defaultValueFactory)
		{
			return endec.decode(ctx, deserializer);
		}
	}
	internal class BinaryReaderMapDeserializer<V> : MapDeserializer<V>, IEnumerator<KeyValuePair<string, V>>, IEnumerator, IDisposable, IEnumerable<KeyValuePair<string, V>>, IEnumerable
	{
		private readonly BinaryReaderDeserializer deserializer;

		private readonly SerializationContext ctx;

		private readonly Endec<V> valueEndec;

		private readonly int size;

		private int index = 0;

		public KeyValuePair<string, V> Current => next();

		public BinaryReaderMapDeserializer(BinaryReaderDeserializer deserializer, SerializationContext ctx, Endec<V> valueEndec, int size)
		{
			this.deserializer = deserializer;
			this.ctx = ctx;
			this.valueEndec = valueEndec;
			this.size = size;
		}

		public int estimatedSize()
		{
			return size;
		}

		public bool MoveNext()
		{
			return index < size;
		}

		public KeyValuePair<string, V> next()
		{
			index++;
			return new KeyValuePair<string, V>(deserializer.readString(ctx), valueEndec.decode(ctx, deserializer));
		}

		public void Dispose()
		{
		}

		public void Reset()
		{
			throw new Exception("As BinaryReader cannot be rewound, Reset(...) cannot be supported");
		}
	}
	public class BinaryWriterSerializer : Serializer<BinaryWriter>
	{
		public static Action<string> DEBUG_HOOK_1 = delegate
		{
		};

		public static Action<long, long> DEBUG_HOOK_2 = delegate
		{
		};

		protected readonly BinaryWriter input;

		protected BinaryWriterSerializer(BinaryWriter input)
		{
			this.input = input;
		}

		public static BinaryWriterSerializer of(BinaryWriter input)
		{
			return new BinaryWriterSerializer(input);
		}

		public void writeByte(SerializationContext ctx, byte value)
		{
			input.Write(value);
		}

		public void writeShort(SerializationContext ctx, short value)
		{
			input.Write(value);
		}

		public void writeInt(SerializationContext ctx, int value)
		{
			input.Write(value);
		}

		public void writeLong(SerializationContext ctx, long value)
		{
			input.Write(value);
		}

		public void writeFloat(SerializationContext ctx, float value)
		{
			input.Write(value);
		}

		public void writeDouble(SerializationContext ctx, double value)
		{
			input.Write(value);
		}

		public void writeVarInt(SerializationContext ctx, int value)
		{
			SerializationContext ctx2 = ctx;
			VarInts.writeInt(value, delegate(byte b)
			{
				writeByte(ctx2, b);
			});
		}

		public void writeVarLong(SerializationContext ctx, long value)
		{
			SerializationContext ctx2 = ctx;
			VarInts.writeLong(value, delegate(byte b)
			{
				writeByte(ctx2, b);
			});
		}

		public void writeBoolean(SerializationContext ctx, bool value)
		{
			input.Write(value);
		}

		public void writeString(SerializationContext ctx, string value)
		{
			DEBUG_HOOK_1(value);
			long arg = -1L;
			if (input.BaseStream is MemoryStream memoryStream)
			{
				arg = memoryStream.Length;
			}
			writeBytes(ctx, Encoding.UTF8.GetBytes(value));
			long arg2 = -1L;
			if (input.BaseStream is MemoryStream memoryStream2)
			{
				arg2 = memoryStream2.Length;
			}
			DEBUG_HOOK_2(arg, arg2);
		}

		public void writeBytes(SerializationContext ctx, byte[] bytes)
		{
			writeVarInt(ctx, bytes.Length);
			input.Write(bytes);
		}

		public void writeOptional<V>(SerializationContext ctx, Endec<V> endec, V? optional)
		{
			if (optional == null)
			{
				writeBoolean(ctx, value: false);
				return;
			}
			writeBoolean(ctx, value: true);
			endec.encode(ctx, this, optional);
		}

		public BinaryWriter result()
		{
			return input;
		}

		public MapSerializer<V> map<V>(SerializationContext ctx, Endec<V> valueEndec, int size)
		{
			writeVarInt(ctx, size);
			return new BinaryWriterSequenceSerializer<V>(this, ctx, valueEndec);
		}

		public SequenceSerializer<E> sequence<E>(SerializationContext ctx, Endec<E> elementEndec, int size)
		{
			writeVarInt(ctx, size);
			return new BinaryWriterSequenceSerializer<E>(this, ctx, elementEndec);
		}

		public StructSerializer structed()
		{
			return new BinaryWriterStructSerializer(this);
		}
	}
	internal class BinaryWriterSequenceSerializer<V> : SequenceSerializer<V>, Endable, IDisposable, MapSerializer<V>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private BinaryWriterSerializer <serializer>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private SerializationContext <ctx>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Endec<V> <valueEndec>P;

		public BinaryWriterSequenceSerializer(BinaryWriterSerializer serializer, SerializationContext ctx, Endec<V> valueEndec)
		{
			<serializer>P = serializer;
			<ctx>P = ctx;
			<valueEndec>P = valueEndec;
			base..ct