readmev1.3.1

2 files changed, 1219 insertions, 89 deletions

diff --git a/README.md b/README.md
index 7ad0d60c..c51fcc30 100644
--- a/README.md
+++ b/README.md
@@ -581,6 +581,7 @@ High-Level API(MessagePackSerializer)
 | `Deserialize<T>` | Convert byte[] or stream to object. There has IFormatterResolver overload, used specified resolver. |
 | `NonGeneric.*` | NonGeneric APIs of Serialize/Deserialize. There accept type parameter at first argument. This API is bit slower than generic API but useful for framework integration such as ASP.NET formatter. |
 | `ToJson` | Dump message-pack binary to JSON string. It is useful for debugging.  |
+| `FromJson` | From Json string to MessagePack binary.  |
 
 MessagePack for C# operates at the byte[] level, so byte[] API is faster than Stream API.
 
@@ -644,12 +645,15 @@ Primitive API(MessagePackBinary)
 | ReadNext | Skip MessagePackFormat binary block, returns read size. |
 | ReadNextBlock | Skip MessagePackFormat binary block with sub structures(array/map), returns read size. This is useful for create deserializer. |
 | Write/ReadMapHeader | Write/Read map format header(element length). |
+| WriteMapHeaderForceMap32Block | Write map format header, always use map32 format(length is fixed, 5). |
 | Write/ReadArrayHeader | Write/Read array format header(element length). |
+| WriteArrayHeaderForceArray32Block | Write array format header, always use array32 format(length is fixed, 5). |
 | Write/Read*** | *** is primitive type name(`Int32`, `Single`, `String`, etc...) |
 | Write***Force***Block | *** is primitive integer name(`Byte`, `Int32`, `UInt64`, etc...), acquire strict block and write code |
 | Write/ReadBytes | Write/Read byte[] to use bin format. |
 | Write/ReadExtensionFormat | Write/Read ext format header(Length + TypeCode) and content byte[]. |
 | Write/ReadExtensionFormatHeader | Write/Read ext format, header(Length + TypeCode) only. |
+| WriteExtensionFormatHeaderForceExt32Block | Write ext format header, always use ext32 format(length is fixed, 6). |
 | IsNil | Is TypeCode Nil? |
 | GetMessagePackType | Return MessagePackType of target MessagePack bianary position. |
 | EnsureCapacity | Resize if byte can not fill.  |
@@ -674,8 +678,9 @@ Extension Point(IFormatterResolver)
 | --- | --- |
 | BuiltinResolver | Builtin primitive and standard classes resolver. It includes primitive(int, bool, string...) and there nullable, array and list. and some extra builtin types(Guid, Uri, BigInteger, etc...). |
 | StandardResolver | Composited resolver . It resolves in the following order `builtin -> attribute -> dynamic enum -> dynamic generic -> dynamic union -> dynamic object -> primitive object`. This is the default of MessagePackSerializer. |
-| ContractlessStandardResolver | Composited `StandardResolver` -> `DynamicContractlessObjectResolver`. It enables contractless serialization. |
+| ContractlessStandardResolver | Composited `StandardResolver`(except primitive) -> `DynamicContractlessObjectResolver` -> `DynamicObjectTypeFallbackResolver`. It enables contractless serialization. |
 | PrimitiveObjectResolver | MessagePack primitive object resolver. It is used fallback in `object` type and supports `bool`, `char`, `sbyte`, `byte`, `short`, `int`, `long`, `ushort`, `uint`, `ulong`, `float`, `double`, `DateTime`, `string`, `byte[]`, `ICollection`, `IDictionary`. |
+| DynamicObjectTypeFallbackResolver | It is used fallback in `object` type and resolve primitive object -> dynamic contractless object |
 | AttributeFormatterResolver | Get formatter from `[MessagePackFormatter]` attribute. |
 | CompositeResolver | Singleton helper of setup custom resolvers. You can use `Register` or `RegisterAndSetAsDefault` API. |
 | NativeDateTimeResolver | Serialize by .NET native DateTime binary format. |
diff --git a/nuget/mpc_check.cs b/nuget/mpc_check.cs
index fecd27ca..615a21e7 100644
--- a/nuget/mpc_check.cs
+++ b/nuget/mpc_check.cs
@@ -43,44 +43,64 @@ namespace MessagePack.Resolvers
 
         static GeneratedResolverGetFormatterHelper()
         {
-            lookup = new global::System.Collections.Generic.Dictionary<Type, int>(36)
-            {
-                {typeof(global::SharedData.ByteEnum), 0 },
-                {typeof(global::SharedData.IUnionChecker), 1 },
-                {typeof(global::SharedData.IUnionChecker2), 2 },
-                {typeof(global::SharedData.IIVersioningUnion), 3 },
-                {typeof(global::SharedData.FirstSimpleData), 4 },
-                {typeof(global::SharedData.SimlpeStringKeyData), 5 },
-                {typeof(global::SharedData.SimpleStructIntKeyData), 6 },
-                {typeof(global::SharedData.SimpleStructStringKeyData), 7 },
-                {typeof(global::SharedData.SimpleIntKeyData), 8 },
-                {typeof(global::SharedData.Vector2), 9 },
-                {typeof(global::SharedData.EmptyClass), 10 },
-                {typeof(global::SharedData.EmptyStruct), 11 },
-                {typeof(global::SharedData.Version1), 12 },
-                {typeof(global::SharedData.Version2), 13 },
-                {typeof(global::SharedData.Version0), 14 },
-                {typeof(global::SharedData.HolderV1), 15 },
-                {typeof(global::SharedData.HolderV2), 16 },
-                {typeof(global::SharedData.HolderV0), 17 },
-                {typeof(global::SharedData.Callback1), 18 },
-                {typeof(global::SharedData.Callback1_2), 19 },
-                {typeof(global::SharedData.Callback2), 20 },
-                {typeof(global::SharedData.Callback2_2), 21 },
-                {typeof(global::SharedData.MySubUnion1), 22 },
-                {typeof(global::SharedData.MySubUnion2), 23 },
-                {typeof(global::SharedData.MySubUnion3), 24 },
-                {typeof(global::SharedData.MySubUnion4), 25 },
-                {typeof(global::SharedData.VersioningUnion), 26 },
-                {typeof(global::SharedData.MyClass), 27 },
-                {typeof(global::SharedData.VersionBlockTest), 28 },
-                {typeof(global::SharedData.UnVersionBlockTest), 29 },
-                {typeof(global::SharedData.Empty1), 30 },
-                {typeof(global::SharedData.Empty2), 31 },
-                {typeof(global::SharedData.NonEmpty1), 32 },
-                {typeof(global::SharedData.NonEmpty2), 33 },
-                {typeof(global::SharedData.VectorLike2), 34 },
-                {typeof(global::SharedData.Vector3Like), 35 },
+            lookup = new global::System.Collections.Generic.Dictionary<Type, int>(56)
+            {
+                {typeof(int[,]), 0 },
+                {typeof(global::GlobalMyEnum[,]), 1 },
+                {typeof(int[,,]), 2 },
+                {typeof(int[,,,]), 3 },
+                {typeof(global::GlobalMyEnum[]), 4 },
+                {typeof(global::QuestMessageBody[]), 5 },
+                {typeof(global::SharedData.ByteEnum), 6 },
+                {typeof(global::GlobalMyEnum), 7 },
+                {typeof(global::SharedData.IUnionChecker), 8 },
+                {typeof(global::SharedData.IUnionChecker2), 9 },
+                {typeof(global::SharedData.IIVersioningUnion), 10 },
+                {typeof(global::SharedData.IUnionSample), 11 },
+                {typeof(global::IMessageBody), 12 },
+                {typeof(global::SharedData.FirstSimpleData), 13 },
+                {typeof(global::SharedData.SimlpeStringKeyData), 14 },
+                {typeof(global::SharedData.SimpleStructIntKeyData), 15 },
+                {typeof(global::SharedData.SimpleStructStringKeyData), 16 },
+                {typeof(global::SharedData.SimpleIntKeyData), 17 },
+                {typeof(global::SharedData.Vector2), 18 },
+                {typeof(global::SharedData.EmptyClass), 19 },
+                {typeof(global::SharedData.EmptyStruct), 20 },
+                {typeof(global::SharedData.Version1), 21 },
+                {typeof(global::SharedData.Version2), 22 },
+                {typeof(global::SharedData.Version0), 23 },
+                {typeof(global::SharedData.HolderV1), 24 },
+                {typeof(global::SharedData.HolderV2), 25 },
+                {typeof(global::SharedData.HolderV0), 26 },
+                {typeof(global::SharedData.Callback1), 27 },
+                {typeof(global::SharedData.Callback1_2), 28 },
+                {typeof(global::SharedData.Callback2), 29 },
+                {typeof(global::SharedData.Callback2_2), 30 },
+                {typeof(global::SharedData.MySubUnion1), 31 },
+                {typeof(global::SharedData.MySubUnion2), 32 },
+                {typeof(global::SharedData.MySubUnion3), 33 },
+                {typeof(global::SharedData.MySubUnion4), 34 },
+                {typeof(global::SharedData.VersioningUnion), 35 },
+                {typeof(global::SharedData.MyClass), 36 },
+                {typeof(global::SharedData.VersionBlockTest), 37 },
+                {typeof(global::SharedData.UnVersionBlockTest), 38 },
+                {typeof(global::SharedData.Empty1), 39 },
+                {typeof(global::SharedData.Empty2), 40 },
+                {typeof(global::SharedData.NonEmpty1), 41 },
+                {typeof(global::SharedData.NonEmpty2), 42 },
+                {typeof(global::SharedData.VectorLike2), 43 },
+                {typeof(global::SharedData.Vector3Like), 44 },
+                {typeof(global::SharedData.ArrayOptimizeClass), 45 },
+                {typeof(global::SharedData.NestParent.NestContract), 46 },
+                {typeof(global::SharedData.FooClass), 47 },
+                {typeof(global::SharedData.BarClass), 48 },
+                {typeof(global::Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad.TnonodsfarnoiuAtatqaga), 49 },
+                {typeof(global::GlobalMan), 50 },
+                {typeof(global::Message), 51 },
+                {typeof(global::TextMessageBody), 52 },
+                {typeof(global::StampMessageBody), 53 },
+                {typeof(global::QuestMessageBody), 54 },
+                {typeof(global::ArrayTestTest), 55 },
             };
         }
 
@@ -91,42 +111,62 @@ namespace MessagePack.Resolvers
 
             switch (key)
             {
-                case 0: return new MessagePack.Formatters.SharedData.ByteEnumFormatter();
-                case 1: return new MessagePack.Formatters.SharedData.IUnionCheckerFormatter();
-                case 2: return new MessagePack.Formatters.SharedData.IUnionChecker2Formatter();
-                case 3: return new MessagePack.Formatters.SharedData.IIVersioningUnionFormatter();
-                case 4: return new MessagePack.Formatters.SharedData.FirstSimpleDataFormatter();
-                case 5: return new MessagePack.Formatters.SharedData.SimlpeStringKeyDataFormatter();
-                case 6: return new MessagePack.Formatters.SharedData.SimpleStructIntKeyDataFormatter();
-                case 7: return new MessagePack.Formatters.SharedData.SimpleStructStringKeyDataFormatter();
-                case 8: return new MessagePack.Formatters.SharedData.SimpleIntKeyDataFormatter();
-                case 9: return new MessagePack.Formatters.SharedData.Vector2Formatter();
-                case 10: return new MessagePack.Formatters.SharedData.EmptyClassFormatter();
-                case 11: return new MessagePack.Formatters.SharedData.EmptyStructFormatter();
-                case 12: return new MessagePack.Formatters.SharedData.Version1Formatter();
-                case 13: return new MessagePack.Formatters.SharedData.Version2Formatter();
-                case 14: return new MessagePack.Formatters.SharedData.Version0Formatter();
-                case 15: return new MessagePack.Formatters.SharedData.HolderV1Formatter();
-                case 16: return new MessagePack.Formatters.SharedData.HolderV2Formatter();
-                case 17: return new MessagePack.Formatters.SharedData.HolderV0Formatter();
-                case 18: return new MessagePack.Formatters.SharedData.Callback1Formatter();
-                case 19: return new MessagePack.Formatters.SharedData.Callback1_2Formatter();
-                case 20: return new MessagePack.Formatters.SharedData.Callback2Formatter();
-                case 21: return new MessagePack.Formatters.SharedData.Callback2_2Formatter();
-                case 22: return new MessagePack.Formatters.SharedData.MySubUnion1Formatter();
-                case 23: return new MessagePack.Formatters.SharedData.MySubUnion2Formatter();
-                case 24: return new MessagePack.Formatters.SharedData.MySubUnion3Formatter();
-                case 25: return new MessagePack.Formatters.SharedData.MySubUnion4Formatter();
-                case 26: return new MessagePack.Formatters.SharedData.VersioningUnionFormatter();
-                case 27: return new MessagePack.Formatters.SharedData.MyClassFormatter();
-                case 28: return new MessagePack.Formatters.SharedData.VersionBlockTestFormatter();
-                case 29: return new MessagePack.Formatters.SharedData.UnVersionBlockTestFormatter();
-                case 30: return new MessagePack.Formatters.SharedData.Empty1Formatter();
-                case 31: return new MessagePack.Formatters.SharedData.Empty2Formatter();
-                case 32: return new MessagePack.Formatters.SharedData.NonEmpty1Formatter();
-                case 33: return new MessagePack.Formatters.SharedData.NonEmpty2Formatter();
-                case 34: return new MessagePack.Formatters.SharedData.VectorLike2Formatter();
-                case 35: return new MessagePack.Formatters.SharedData.Vector3LikeFormatter();
+                case 0: return new global::MessagePack.Formatters.TwoDimentionalArrayFormatter<int>();
+                case 1: return new global::MessagePack.Formatters.TwoDimentionalArrayFormatter<global::GlobalMyEnum>();
+                case 2: return new global::MessagePack.Formatters.ThreeDimentionalArrayFormatter<int>();
+                case 3: return new global::MessagePack.Formatters.FourDimentionalArrayFormatter<int>();
+                case 4: return new global::MessagePack.Formatters.ArrayFormatter<global::GlobalMyEnum>();
+                case 5: return new global::MessagePack.Formatters.ArrayFormatter<global::QuestMessageBody>();
+                case 6: return new MessagePack.Formatters.SharedData.ByteEnumFormatter();
+                case 7: return new MessagePack.Formatters.GlobalMyEnumFormatter();
+                case 8: return new MessagePack.Formatters.SharedData.IUnionCheckerFormatter();
+                case 9: return new MessagePack.Formatters.SharedData.IUnionChecker2Formatter();
+                case 10: return new MessagePack.Formatters.SharedData.IIVersioningUnionFormatter();
+                case 11: return new MessagePack.Formatters.SharedData.IUnionSampleFormatter();
+                case 12: return new MessagePack.Formatters.IMessageBodyFormatter();
+                case 13: return new MessagePack.Formatters.SharedData.FirstSimpleDataFormatter();
+                case 14: return new MessagePack.Formatters.SharedData.SimlpeStringKeyDataFormatter();
+                case 15: return new MessagePack.Formatters.SharedData.SimpleStructIntKeyDataFormatter();
+                case 16: return new MessagePack.Formatters.SharedData.SimpleStructStringKeyDataFormatter();
+                case 17: return new MessagePack.Formatters.SharedData.SimpleIntKeyDataFormatter();
+                case 18: return new MessagePack.Formatters.SharedData.Vector2Formatter();
+                case 19: return new MessagePack.Formatters.SharedData.EmptyClassFormatter();
+                case 20: return new MessagePack.Formatters.SharedData.EmptyStructFormatter();
+                case 21: return new MessagePack.Formatters.SharedData.Version1Formatter();
+                case 22: return new MessagePack.Formatters.SharedData.Version2Formatter();
+                case 23: return new MessagePack.Formatters.SharedData.Version0Formatter();
+                case 24: return new MessagePack.Formatters.SharedData.HolderV1Formatter();
+                case 25: return new MessagePack.Formatters.SharedData.HolderV2Formatter();
+                case 26: return new MessagePack.Formatters.SharedData.HolderV0Formatter();
+                case 27: return new MessagePack.Formatters.SharedData.Callback1Formatter();
+                case 28: return new MessagePack.Formatters.SharedData.Callback1_2Formatter();
+                case 29: return new MessagePack.Formatters.SharedData.Callback2Formatter();
+                case 30: return new MessagePack.Formatters.SharedData.Callback2_2Formatter();
+                case 31: return new MessagePack.Formatters.SharedData.MySubUnion1Formatter();
+                case 32: return new MessagePack.Formatters.SharedData.MySubUnion2Formatter();
+                case 33: return new MessagePack.Formatters.SharedData.MySubUnion3Formatter();
+                case 34: return new MessagePack.Formatters.SharedData.MySubUnion4Formatter();
+                case 35: return new MessagePack.Formatters.SharedData.VersioningUnionFormatter();
+                case 36: return new MessagePack.Formatters.SharedData.MyClassFormatter();
+                case 37: return new MessagePack.Formatters.SharedData.VersionBlockTestFormatter();
+                case 38: return new MessagePack.Formatters.SharedData.UnVersionBlockTestFormatter();
+                case 39: return new MessagePack.Formatters.SharedData.Empty1Formatter();
+                case 40: return new MessagePack.Formatters.SharedData.Empty2Formatter();
+                case 41: return new MessagePack.Formatters.SharedData.NonEmpty1Formatter();
+                case 42: return new MessagePack.Formatters.SharedData.NonEmpty2Formatter();
+                case 43: return new MessagePack.Formatters.SharedData.VectorLike2Formatter();
+                case 44: return new MessagePack.Formatters.SharedData.Vector3LikeFormatter();
+                case 45: return new MessagePack.Formatters.SharedData.ArrayOptimizeClassFormatter();
+                case 46: return new MessagePack.Formatters.SharedData.NestParent_NestContractFormatter();
+                case 47: return new MessagePack.Formatters.SharedData.FooClassFormatter();
+                case 48: return new MessagePack.Formatters.SharedData.BarClassFormatter();
+                case 49: return new MessagePack.Formatters.Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad.TnonodsfarnoiuAtatqagaFormatter();
+                case 50: return new MessagePack.Formatters.GlobalManFormatter();
+                case 51: return new MessagePack.Formatters.MessageFormatter();
+                case 52: return new MessagePack.Formatters.TextMessageBodyFormatter();
+                case 53: return new MessagePack.Formatters.StampMessageBodyFormatter();
+                case 54: return new MessagePack.Formatters.QuestMessageBodyFormatter();
+                case 55: return new MessagePack.Formatters.ArrayTestTestFormatter();
                 default: return null;
             }
         }
@@ -168,6 +208,36 @@ namespace MessagePack.Formatters.SharedData
 #pragma warning restore 414
 #pragma warning restore 618
 #pragma warning restore 612
+#pragma warning disable 618
+#pragma warning disable 612
+#pragma warning disable 414
+#pragma warning disable 168
+
+namespace MessagePack.Formatters
+{
+    using System;
+    using MessagePack;
+
+    public sealed class GlobalMyEnumFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::GlobalMyEnum>
+    {
+        public int Serialize(ref byte[] bytes, int offset, global::GlobalMyEnum value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            return MessagePackBinary.WriteInt32(ref bytes, offset, (Int32)value);
+        }
+        
+        public global::GlobalMyEnum Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            return (global::GlobalMyEnum)MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+        }
+    }
+
+
+}
+
+#pragma warning disable 168
+#pragma warning restore 414
+#pragma warning restore 618
+#pragma warning restore 612
 
 #pragma warning disable 618
 #pragma warning disable 612
@@ -254,6 +324,11 @@ namespace MessagePack.Formatters.SharedData
 			var key = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
 			offset += readSize;
 
+            if (!this.keyToJumpMap.TryGetValue(key, out key))
+			{
+				key = -1;
+			}
+
 			global::SharedData.IUnionChecker result = null;
 			switch (key)
 			{
@@ -358,6 +433,11 @@ namespace MessagePack.Formatters.SharedData
 			var key = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
 			offset += readSize;
 
+            if (!this.keyToJumpMap.TryGetValue(key, out key))
+			{
+				key = -1;
+			}
+
 			global::SharedData.IUnionChecker2 result = null;
 			switch (key)
 			{
@@ -447,6 +527,11 @@ namespace MessagePack.Formatters.SharedData
 			var key = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
 			offset += readSize;
 
+            if (!this.keyToJumpMap.TryGetValue(key, out key))
+			{
+				key = -1;
+			}
+
 			global::SharedData.IIVersioningUnion result = null;
 			switch (key)
 			{
@@ -465,6 +550,215 @@ namespace MessagePack.Formatters.SharedData
         }
     }
 
+    public sealed class IUnionSampleFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::SharedData.IUnionSample>
+    {
+		readonly Dictionary<RuntimeTypeHandle, KeyValuePair<int, int>> typeToKeyAndJumpMap;
+		readonly Dictionary<int, int> keyToJumpMap;
+
+		public IUnionSampleFormatter()
+		{
+			this.typeToKeyAndJumpMap = new Dictionary<RuntimeTypeHandle, KeyValuePair<int, int>>(2, global::MessagePack.Internal.RuntimeTypeHandleEqualityComparer.Default)
+			{
+				{ typeof(global::SharedData.FooClass).TypeHandle, new KeyValuePair<int, int>(0, 0) },
+				{ typeof(global::SharedData.BarClass).TypeHandle, new KeyValuePair<int, int>(100, 1) },
+			};
+			this.keyToJumpMap = new Dictionary<int, int>(2)
+			{
+				{ 0, 0 },
+				{ 100, 1 },
+			};
+		}
+
+        public int Serialize(ref byte[] bytes, int offset, global::SharedData.IUnionSample value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+			KeyValuePair<int, int> keyValuePair;
+			if (value != null && this.typeToKeyAndJumpMap.TryGetValue(value.GetType().TypeHandle, out keyValuePair))
+			{
+				var startOffset = offset;
+				offset += MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2);
+				offset += MessagePackBinary.WriteInt32(ref bytes, offset, keyValuePair.Key);
+				switch (keyValuePair.Value)
+				{
+					case 0:
+						offset += formatterResolver.GetFormatterWithVerify<global::SharedData.FooClass>().Serialize(ref bytes, offset, (global::SharedData.FooClass)value, formatterResolver);
+						break;
+					case 1:
+						offset += formatterResolver.GetFormatterWithVerify<global::SharedData.BarClass>().Serialize(ref bytes, offset, (global::SharedData.BarClass)value, formatterResolver);
+						break;
+					default:
+						break;
+				}
+
+				return offset - startOffset;
+			}
+
+			return MessagePackBinary.WriteNil(ref bytes, offset);
+        }
+        
+        public global::SharedData.IUnionSample Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (MessagePackBinary.IsNil(bytes, offset))
+			{
+				readSize = 1;
+				return null;
+			}
+
+			var startOffset = offset;
+			
+			if (MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize) != 2)
+			{
+				throw new InvalidOperationException("Invalid Union data was detected. Type:global::SharedData.IUnionSample");
+			}
+			offset += readSize;
+
+			var key = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+			offset += readSize;
+
+            if (!this.keyToJumpMap.TryGetValue(key, out key))
+			{
+				key = -1;
+			}
+
+			global::SharedData.IUnionSample result = null;
+			switch (key)
+			{
+				case 0:
+					result = (global::SharedData.IUnionSample)formatterResolver.GetFormatterWithVerify<global::SharedData.FooClass>().Deserialize(bytes, offset, formatterResolver, out readSize);
+					offset += readSize;
+					break;
+				case 1:
+					result = (global::SharedData.IUnionSample)formatterResolver.GetFormatterWithVerify<global::SharedData.BarClass>().Deserialize(bytes, offset, formatterResolver, out readSize);
+					offset += readSize;
+					break;
+				default:
+					offset += MessagePackBinary.ReadNextBlock(bytes, offset);
+					break;
+			}
+			
+			readSize = offset - startOffset;
+			
+			return result;
+        }
+    }
+
+
+}
+
+#pragma warning disable 168
+#pragma warning restore 414
+#pragma warning restore 618
+#pragma warning restore 612
+#pragma warning disable 618
+#pragma warning disable 612
+#pragma warning disable 414
+#pragma warning disable 168
+
+namespace MessagePack.Formatters
+{
+    using System;
+	using System.Collections.Generic;
+    using MessagePack;
+
+    public sealed class IMessageBodyFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::IMessageBody>
+    {
+		readonly Dictionary<RuntimeTypeHandle, KeyValuePair<int, int>> typeToKeyAndJumpMap;
+		readonly Dictionary<int, int> keyToJumpMap;
+
+		public IMessageBodyFormatter()
+		{
+			this.typeToKeyAndJumpMap = new Dictionary<RuntimeTypeHandle, KeyValuePair<int, int>>(3, global::MessagePack.Internal.RuntimeTypeHandleEqualityComparer.Default)
+			{
+				{ typeof(global::TextMessageBody).TypeHandle, new KeyValuePair<int, int>(10, 0) },
+				{ typeof(global::StampMessageBody).TypeHandle, new KeyValuePair<int, int>(14, 1) },
+				{ typeof(global::QuestMessageBody).TypeHandle, new KeyValuePair<int, int>(25, 2) },
+			};
+			this.keyToJumpMap = new Dictionary<int, int>(3)
+			{
+				{ 10, 0 },
+				{ 14, 1 },
+				{ 25, 2 },
+			};
+		}
+
+        public int Serialize(ref byte[] bytes, int offset, global::IMessageBody value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+			KeyValuePair<int, int> keyValuePair;
+			if (value != null && this.typeToKeyAndJumpMap.TryGetValue(value.GetType().TypeHandle, out keyValuePair))
+			{
+				var startOffset = offset;
+				offset += MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2);
+				offset += MessagePackBinary.WriteInt32(ref bytes, offset, keyValuePair.Key);
+				switch (keyValuePair.Value)
+				{
+					case 0:
+						offset += formatterResolver.GetFormatterWithVerify<global::TextMessageBody>().Serialize(ref bytes, offset, (global::TextMessageBody)value, formatterResolver);
+						break;
+					case 1:
+						offset += formatterResolver.GetFormatterWithVerify<global::StampMessageBody>().Serialize(ref bytes, offset, (global::StampMessageBody)value, formatterResolver);
+						break;
+					case 2:
+						offset += formatterResolver.GetFormatterWithVerify<global::QuestMessageBody>().Serialize(ref bytes, offset, (global::QuestMessageBody)value, formatterResolver);
+						break;
+					default:
+						break;
+				}
+
+				return offset - startOffset;
+			}
+
+			return MessagePackBinary.WriteNil(ref bytes, offset);
+        }
+        
+        public global::IMessageBody Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (MessagePackBinary.IsNil(bytes, offset))
+			{
+				readSize = 1;
+				return null;
+			}
+
+			var startOffset = offset;
+			
+			if (MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize) != 2)
+			{
+				throw new InvalidOperationException("Invalid Union data was detected. Type:global::IMessageBody");
+			}
+			offset += readSize;
+
+			var key = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+			offset += readSize;
+
+            if (!this.keyToJumpMap.TryGetValue(key, out key))
+			{
+				key = -1;
+			}
+
+			global::IMessageBody result = null;
+			switch (key)
+			{
+				case 0:
+					result = (global::IMessageBody)formatterResolver.GetFormatterWithVerify<global::TextMessageBody>().Deserialize(bytes, offset, formatterResolver, out readSize);
+					offset += readSize;
+					break;
+				case 1:
+					result = (global::IMessageBody)formatterResolver.GetFormatterWithVerify<global::StampMessageBody>().Deserialize(bytes, offset, formatterResolver, out readSize);
+					offset += readSize;
+					break;
+				case 2:
+					result = (global::IMessageBody)formatterResolver.GetFormatterWithVerify<global::QuestMessageBody>().Deserialize(bytes, offset, formatterResolver, out readSize);
+					offset += readSize;
+					break;
+				default:
+					offset += MessagePackBinary.ReadNextBlock(bytes, offset);
+					break;
+			}
+			
+			readSize = offset - startOffset;
+			
+			return result;
+        }
+    }
+
 
 }
 
@@ -555,6 +849,7 @@ namespace MessagePack.Formatters.SharedData
     {
 
         readonly global::System.Collections.Generic.Dictionary<string, int> ____keyMapping;
+        readonly byte[][] ____stringByteKeys;
 
         public SimlpeStringKeyDataFormatter()
         {
@@ -564,6 +859,14 @@ namespace MessagePack.Formatters.SharedData
                 { "Prop2", 1},
                 { "Prop3", 2},
             };
+
+            this.____stringByteKeys = new byte[][]
+            {
+                global::System.Text.Encoding.UTF8.GetBytes("Prop1"),
+                global::System.Text.Encoding.UTF8.GetBytes("Prop2"),
+                global::System.Text.Encoding.UTF8.GetBytes("Prop3"),
+                
+            };
         }
 
 
@@ -576,11 +879,11 @@ namespace MessagePack.Formatters.SharedData
             
             var startOffset = offset;
             offset += global::MessagePack.MessagePackBinary.WriteFixedMapHeaderUnsafe(ref bytes, offset, 3);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "Prop1", 5);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[0]);
             offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.Prop1);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "Prop2", 5);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[1]);
             offset += formatterResolver.GetFormatterWithVerify<global::SharedData.ByteEnum>().Serialize(ref bytes, offset, value.Prop2, formatterResolver);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "Prop3", 5);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[2]);
             offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.Prop3);
             return offset - startOffset;
         }
@@ -606,7 +909,7 @@ namespace MessagePack.Formatters.SharedData
                 var stringKey = global::MessagePack.MessagePackBinary.ReadString(bytes, offset, out readSize);
                 offset += readSize;
                 int key;
-                if (____keyMapping.TryGetValue(stringKey, out key))
+                if (!____keyMapping.TryGetValue(stringKey, out key))
                 {
                     readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                     goto NEXT_LOOP;
@@ -709,6 +1012,7 @@ namespace MessagePack.Formatters.SharedData
     {
 
         readonly global::System.Collections.Generic.Dictionary<string, int> ____keyMapping;
+        readonly byte[][] ____stringByteKeys;
 
         public SimpleStructStringKeyDataFormatter()
         {
@@ -717,6 +1021,13 @@ namespace MessagePack.Formatters.SharedData
                 { "key-X", 0},
                 { "key-Y", 1},
             };
+
+            this.____stringByteKeys = new byte[][]
+            {
+                global::System.Text.Encoding.UTF8.GetBytes("key-X"),
+                global::System.Text.Encoding.UTF8.GetBytes("key-Y"),
+                
+            };
         }
 
 
@@ -725,9 +1036,9 @@ namespace MessagePack.Formatters.SharedData
             
             var startOffset = offset;
             offset += global::MessagePack.MessagePackBinary.WriteFixedMapHeaderUnsafe(ref bytes, offset, 2);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "key-X", 5);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[0]);
             offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.X);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "key-Y", 5);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[1]);
             offset += formatterResolver.GetFormatterWithVerify<int[]>().Serialize(ref bytes, offset, value.Y, formatterResolver);
             return offset - startOffset;
         }
@@ -751,7 +1062,7 @@ namespace MessagePack.Formatters.SharedData
                 var stringKey = global::MessagePack.MessagePackBinary.ReadString(bytes, offset, out readSize);
                 offset += readSize;
                 int key;
-                if (____keyMapping.TryGetValue(stringKey, out key))
+                if (!____keyMapping.TryGetValue(stringKey, out key))
                 {
                     readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                     goto NEXT_LOOP;
@@ -1528,6 +1839,7 @@ namespace MessagePack.Formatters.SharedData
     {
 
         readonly global::System.Collections.Generic.Dictionary<string, int> ____keyMapping;
+        readonly byte[][] ____stringByteKeys;
 
         public Callback2Formatter()
         {
@@ -1535,6 +1847,12 @@ namespace MessagePack.Formatters.SharedData
             {
                 { "X", 0},
             };
+
+            this.____stringByteKeys = new byte[][]
+            {
+                global::System.Text.Encoding.UTF8.GetBytes("X"),
+                
+            };
         }
 
 
@@ -1544,7 +1862,7 @@ namespace MessagePack.Formatters.SharedData
             value.OnBeforeSerialize();
             var startOffset = offset;
             offset += global::MessagePack.MessagePackBinary.WriteFixedMapHeaderUnsafe(ref bytes, offset, 1);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "X", 1);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[0]);
             offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.X);
             return offset - startOffset;
         }
@@ -1567,7 +1885,7 @@ namespace MessagePack.Formatters.SharedData
                 var stringKey = global::MessagePack.MessagePackBinary.ReadString(bytes, offset, out readSize);
                 offset += readSize;
                 int key;
-                if (____keyMapping.TryGetValue(stringKey, out key))
+                if (!____keyMapping.TryGetValue(stringKey, out key))
                 {
                     readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                     goto NEXT_LOOP;
@@ -1601,6 +1919,7 @@ namespace MessagePack.Formatters.SharedData
     {
 
         readonly global::System.Collections.Generic.Dictionary<string, int> ____keyMapping;
+        readonly byte[][] ____stringByteKeys;
 
         public Callback2_2Formatter()
         {
@@ -1608,6 +1927,12 @@ namespace MessagePack.Formatters.SharedData
             {
                 { "X", 0},
             };
+
+            this.____stringByteKeys = new byte[][]
+            {
+                global::System.Text.Encoding.UTF8.GetBytes("X"),
+                
+            };
         }
 
 
@@ -1617,7 +1942,7 @@ namespace MessagePack.Formatters.SharedData
             ((IMessagePackSerializationCallbackReceiver)value).OnBeforeSerialize();
             var startOffset = offset;
             offset += global::MessagePack.MessagePackBinary.WriteFixedMapHeaderUnsafe(ref bytes, offset, 1);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "X", 1);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[0]);
             offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.X);
             return offset - startOffset;
         }
@@ -1640,7 +1965,7 @@ namespace MessagePack.Formatters.SharedData
                 var stringKey = global::MessagePack.MessagePackBinary.ReadString(bytes, offset, out readSize);
                 offset += readSize;
                 int key;
-                if (____keyMapping.TryGetValue(stringKey, out key))
+                if (!____keyMapping.TryGetValue(stringKey, out key))
                 {
                     readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                     goto NEXT_LOOP;
@@ -2208,12 +2533,18 @@ namespace MessagePack.Formatters.SharedData
     {
 
         readonly global::System.Collections.Generic.Dictionary<string, int> ____keyMapping;
+        readonly byte[][] ____stringByteKeys;
 
         public Empty2Formatter()
         {
             this.____keyMapping = new global::System.Collections.Generic.Dictionary<string, int>(0)
             {
             };
+
+            this.____stringByteKeys = new byte[][]
+            {
+                
+            };
         }
 
 
@@ -2247,7 +2578,7 @@ namespace MessagePack.Formatters.SharedData
                 var stringKey = global::MessagePack.MessagePackBinary.ReadString(bytes, offset, out readSize);
                 offset += readSize;
                 int key;
-                if (____keyMapping.TryGetValue(stringKey, out key))
+                if (!____keyMapping.TryGetValue(stringKey, out key))
                 {
                     readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                     goto NEXT_LOOP;
@@ -2331,6 +2662,7 @@ namespace MessagePack.Formatters.SharedData
     {
 
         readonly global::System.Collections.Generic.Dictionary<string, int> ____keyMapping;
+        readonly byte[][] ____stringByteKeys;
 
         public NonEmpty2Formatter()
         {
@@ -2338,6 +2670,12 @@ namespace MessagePack.Formatters.SharedData
             {
                 { "MyProperty", 0},
             };
+
+            this.____stringByteKeys = new byte[][]
+            {
+                global::System.Text.Encoding.UTF8.GetBytes("MyProperty"),
+                
+            };
         }
 
 
@@ -2350,7 +2688,7 @@ namespace MessagePack.Formatters.SharedData
             
             var startOffset = offset;
             offset += global::MessagePack.MessagePackBinary.WriteFixedMapHeaderUnsafe(ref bytes, offset, 1);
-            offset += global::MessagePack.MessagePackBinary.WriteStringUnsafe(ref bytes, offset, "MyProperty", 10);
+            offset += global::MessagePack.MessagePackBinary.WriteStringBytes(ref bytes, offset, this.____stringByteKeys[0]);
             offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty);
             return offset - startOffset;
         }
@@ -2374,7 +2712,7 @@ namespace MessagePack.Formatters.SharedData
                 var stringKey = global::MessagePack.MessagePackBinary.ReadString(bytes, offset, out readSize);
                 offset += readSize;
                 int key;
-                if (____keyMapping.TryGetValue(stringKey, out key))
+                if (!____keyMapping.TryGetValue(stringKey, out key))
                 {
                     readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
                     goto NEXT_LOOP;
@@ -2520,6 +2858,793 @@ namespace MessagePack.Formatters.SharedData
         }
     }
 
+
+    public sealed class ArrayOptimizeClassFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::SharedData.ArrayOptimizeClass>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::SharedData.ArrayOptimizeClass value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteArrayHeader(ref bytes, offset, 16);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty0);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty1);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty2);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty3);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty4);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty5);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty6);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty7);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty8);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProvperty9);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty10);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty11);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyPropverty12);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyPropevrty13);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty14);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty15);
+            return offset - startOffset;
+        }
+
+        public global::SharedData.ArrayOptimizeClass Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __MyProperty0__ = default(int);
+            var __MyProperty1__ = default(int);
+            var __MyProperty2__ = default(int);
+            var __MyProperty3__ = default(int);
+            var __MyProperty4__ = default(int);
+            var __MyProperty5__ = default(int);
+            var __MyProperty6__ = default(int);
+            var __MyProperty7__ = default(int);
+            var __MyProperty8__ = default(int);
+            var __MyProvperty9__ = default(int);
+            var __MyProperty10__ = default(int);
+            var __MyProperty11__ = default(int);
+            var __MyPropverty12__ = default(int);
+            var __MyPropevrty13__ = default(int);
+            var __MyProperty14__ = default(int);
+            var __MyProperty15__ = default(int);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __MyProperty0__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 1:
+                        __MyProperty1__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 2:
+                        __MyProperty2__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 3:
+                        __MyProperty3__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 4:
+                        __MyProperty4__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 5:
+                        __MyProperty5__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 6:
+                        __MyProperty6__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 7:
+                        __MyProperty7__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 8:
+                        __MyProperty8__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 9:
+                        __MyProvperty9__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 10:
+                        __MyProperty10__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 11:
+                        __MyProperty11__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 12:
+                        __MyPropverty12__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 13:
+                        __MyPropevrty13__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 14:
+                        __MyProperty14__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 15:
+                        __MyProperty15__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::SharedData.ArrayOptimizeClass();
+            ____result.MyProperty0 = __MyProperty0__;
+            ____result.MyProperty1 = __MyProperty1__;
+            ____result.MyProperty2 = __MyProperty2__;
+            ____result.MyProperty3 = __MyProperty3__;
+            ____result.MyProperty4 = __MyProperty4__;
+            ____result.MyProperty5 = __MyProperty5__;
+            ____result.MyProperty6 = __MyProperty6__;
+            ____result.MyProperty7 = __MyProperty7__;
+            ____result.MyProperty8 = __MyProperty8__;
+            ____result.MyProvperty9 = __MyProvperty9__;
+            ____result.MyProperty10 = __MyProperty10__;
+            ____result.MyProperty11 = __MyProperty11__;
+            ____result.MyPropverty12 = __MyPropverty12__;
+            ____result.MyPropevrty13 = __MyPropevrty13__;
+            ____result.MyProperty14 = __MyProperty14__;
+            ____result.MyProperty15 = __MyProperty15__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class NestParent_NestContractFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::SharedData.NestParent.NestContract>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::SharedData.NestParent.NestContract value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty);
+            return offset - startOffset;
+        }
+
+        public global::SharedData.NestParent.NestContract Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __MyProperty__ = default(int);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __MyProperty__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::SharedData.NestParent.NestContract();
+            ____result.MyProperty = __MyProperty__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class FooClassFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::SharedData.FooClass>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::SharedData.FooClass value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.XYZ);
+            return offset - startOffset;
+        }
+
+        public global::SharedData.FooClass Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __XYZ__ = default(int);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __XYZ__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::SharedData.FooClass();
+            ____result.XYZ = __XYZ__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class BarClassFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::SharedData.BarClass>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::SharedData.BarClass value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.OPQ, formatterResolver);
+            return offset - startOffset;
+        }
+
+        public global::SharedData.BarClass Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __OPQ__ = default(string);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __OPQ__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::SharedData.BarClass();
+            ____result.OPQ = __OPQ__;
+            return ____result;
+        }
+    }
+
+}
+
+#pragma warning disable 168
+#pragma warning restore 414
+#pragma warning restore 618
+#pragma warning restore 612
+#pragma warning disable 618
+#pragma warning disable 612
+#pragma warning disable 414
+#pragma warning disable 168
+
+namespace MessagePack.Formatters.Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad
+{
+    using System;
+    using MessagePack;
+
+
+    public sealed class TnonodsfarnoiuAtatqagaFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad.TnonodsfarnoiuAtatqaga>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad.TnonodsfarnoiuAtatqaga value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty);
+            return offset - startOffset;
+        }
+
+        public global::Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad.TnonodsfarnoiuAtatqaga Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __MyProperty__ = default(int);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __MyProperty__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::Abcdefg.Efcdigjl.Ateatatea.Hgfagfafgad.TnonodsfarnoiuAtatqaga();
+            ____result.MyProperty = __MyProperty__;
+            return ____result;
+        }
+    }
+
+}
+
+#pragma warning disable 168
+#pragma warning restore 414
+#pragma warning restore 618
+#pragma warning restore 612
+#pragma warning disable 618
+#pragma warning disable 612
+#pragma warning disable 414
+#pragma warning disable 168
+
+namespace MessagePack.Formatters
+{
+    using System;
+    using MessagePack;
+
+
+    public sealed class GlobalManFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::GlobalMan>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::GlobalMan value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.MyProperty);
+            return offset - startOffset;
+        }
+
+        public global::GlobalMan Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __MyProperty__ = default(int);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __MyProperty__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::GlobalMan();
+            ____result.MyProperty = __MyProperty__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class MessageFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::Message>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::Message value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 4);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.UserId);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.RoomId);
+            offset += formatterResolver.GetFormatterWithVerify<global::System.DateTime>().Serialize(ref bytes, offset, value.PostTime, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<global::IMessageBody>().Serialize(ref bytes, offset, value.Body, formatterResolver);
+            return offset - startOffset;
+        }
+
+        public global::Message Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __UserId__ = default(int);
+            var __RoomId__ = default(int);
+            var __PostTime__ = default(global::System.DateTime);
+            var __Body__ = default(global::IMessageBody);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __UserId__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 1:
+                        __RoomId__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 2:
+                        __PostTime__ = formatterResolver.GetFormatterWithVerify<global::System.DateTime>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 3:
+                        __Body__ = formatterResolver.GetFormatterWithVerify<global::IMessageBody>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::Message();
+            ____result.UserId = __UserId__;
+            ____result.RoomId = __RoomId__;
+            ____result.PostTime = __PostTime__;
+            ____result.Body = __Body__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class TextMessageBodyFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::TextMessageBody>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::TextMessageBody value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.Text, formatterResolver);
+            return offset - startOffset;
+        }
+
+        public global::TextMessageBody Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __Text__ = default(string);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __Text__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::TextMessageBody();
+            ____result.Text = __Text__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class StampMessageBodyFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::StampMessageBody>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::StampMessageBody value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 1);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.StampId);
+            return offset - startOffset;
+        }
+
+        public global::StampMessageBody Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __StampId__ = default(int);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __StampId__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::StampMessageBody();
+            ____result.StampId = __StampId__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class QuestMessageBodyFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::QuestMessageBody>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::QuestMessageBody value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 2);
+            offset += MessagePackBinary.WriteInt32(ref bytes, offset, value.QuestId);
+            offset += formatterResolver.GetFormatterWithVerify<string>().Serialize(ref bytes, offset, value.Text, formatterResolver);
+            return offset - startOffset;
+        }
+
+        public global::QuestMessageBody Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __QuestId__ = default(int);
+            var __Text__ = default(string);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __QuestId__ = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
+                        break;
+                    case 1:
+                        __Text__ = formatterResolver.GetFormatterWithVerify<string>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::QuestMessageBody();
+            ____result.QuestId = __QuestId__;
+            ____result.Text = __Text__;
+            return ____result;
+        }
+    }
+
+
+    public sealed class ArrayTestTestFormatter : global::MessagePack.Formatters.IMessagePackFormatter<global::ArrayTestTest>
+    {
+
+        public int Serialize(ref byte[] bytes, int offset, global::ArrayTestTest value, global::MessagePack.IFormatterResolver formatterResolver)
+        {
+            if (value == null)
+            {
+                return global::MessagePack.MessagePackBinary.WriteNil(ref bytes, offset);
+            }
+            
+            var startOffset = offset;
+            offset += global::MessagePack.MessagePackBinary.WriteFixedArrayHeaderUnsafe(ref bytes, offset, 7);
+            offset += formatterResolver.GetFormatterWithVerify<int[]>().Serialize(ref bytes, offset, value.MyProperty0, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<int[,]>().Serialize(ref bytes, offset, value.MyProperty1, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<global::GlobalMyEnum[,]>().Serialize(ref bytes, offset, value.MyProperty2, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<int[,,]>().Serialize(ref bytes, offset, value.MyProperty3, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<int[,,,]>().Serialize(ref bytes, offset, value.MyProperty4, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<global::GlobalMyEnum[]>().Serialize(ref bytes, offset, value.MyProperty5, formatterResolver);
+            offset += formatterResolver.GetFormatterWithVerify<global::QuestMessageBody[]>().Serialize(ref bytes, offset, value.MyProperty6, formatterResolver);
+            return offset - startOffset;
+        }
+
+        public global::ArrayTestTest Deserialize(byte[] bytes, int offset, global::MessagePack.IFormatterResolver formatterResolver, out int readSize)
+        {
+            if (global::MessagePack.MessagePackBinary.IsNil(bytes, offset))
+            {
+                readSize = 1;
+                return null;
+            }
+
+            var startOffset = offset;
+            var length = global::MessagePack.MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
+            offset += readSize;
+
+            var __MyProperty0__ = default(int[]);
+            var __MyProperty1__ = default(int[,]);
+            var __MyProperty2__ = default(global::GlobalMyEnum[,]);
+            var __MyProperty3__ = default(int[,,]);
+            var __MyProperty4__ = default(int[,,,]);
+            var __MyProperty5__ = default(global::GlobalMyEnum[]);
+            var __MyProperty6__ = default(global::QuestMessageBody[]);
+
+            for (int i = 0; i < length; i++)
+            {
+                var key = i;
+
+                switch (key)
+                {
+                    case 0:
+                        __MyProperty0__ = formatterResolver.GetFormatterWithVerify<int[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 1:
+                        __MyProperty1__ = formatterResolver.GetFormatterWithVerify<int[,]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 2:
+                        __MyProperty2__ = formatterResolver.GetFormatterWithVerify<global::GlobalMyEnum[,]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 3:
+                        __MyProperty3__ = formatterResolver.GetFormatterWithVerify<int[,,]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 4:
+                        __MyProperty4__ = formatterResolver.GetFormatterWithVerify<int[,,,]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 5:
+                        __MyProperty5__ = formatterResolver.GetFormatterWithVerify<global::GlobalMyEnum[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    case 6:
+                        __MyProperty6__ = formatterResolver.GetFormatterWithVerify<global::QuestMessageBody[]>().Deserialize(bytes, offset, formatterResolver, out readSize);
+                        break;
+                    default:
+                        readSize = global::MessagePack.MessagePackBinary.ReadNextBlock(bytes, offset);
+                        break;
+                }
+                offset += readSize;
+            }
+
+            readSize = offset - startOffset;
+
+            var ____result = new global::ArrayTestTest();
+            ____result.MyProperty0 = __MyProperty0__;
+            ____result.MyProperty1 = __MyProperty1__;
+            ____result.MyProperty2 = __MyProperty2__;
+            ____result.MyProperty3 = __MyProperty3__;
+            ____result.MyProperty4 = __MyProperty4__;
+            ____result.MyProperty5 = __MyProperty5__;
+            ____result.MyProperty6 = __MyProperty6__;
+            return ____result;
+        }
+    }
+
 }
 
 #pragma warning disable 168