From 23458f66f0eac153dd97a5a933da4361ab618d34 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 4 May 2020 18:29:01 +0900
Subject: [PATCH 01/82] Get copy of SequenceReader of corefx.

---
 src/MsgPack.Abstraction/BlockReader`1.cs | 455 +++++++++++++++++++++++
 1 file changed, 455 insertions(+)
 create mode 100644 src/MsgPack.Abstraction/BlockReader`1.cs

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
new file mode 100644
index 000000000..f7a1b8efd
--- /dev/null
+++ b/src/MsgPack.Abstraction/BlockReader`1.cs
@@ -0,0 +1,455 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Internal.Runtime.CompilerServices;
+
+namespace System.Buffers
+{
+    public ref partial struct SequenceReader<T> where T : unmanaged, IEquatable<T>
+    {
+        private SequencePosition _currentPosition;
+        private SequencePosition _nextPosition;
+        private bool _moreData;
+        private readonly long _length;
+
+        /// <summary>
+        /// Create a <see cref="SequenceReader{T}"/> over the given <see cref="ReadOnlySequence{T}"/>.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public SequenceReader(ReadOnlySequence<T> sequence)
+        {
+            CurrentSpanIndex = 0;
+            Consumed = 0;
+            Sequence = sequence;
+            _currentPosition = sequence.Start;
+            _length = -1;
+
+            sequence.GetFirstSpan(out ReadOnlySpan<T> first, out _nextPosition);
+            CurrentSpan = first;
+            _moreData = first.Length > 0;
+
+            if (!_moreData && !sequence.IsSingleSegment)
+            {
+                _moreData = true;
+                GetNextSpan();
+            }
+        }
+
+        /// <summary>
+        /// True when there is no more data in the <see cref="Sequence"/>.
+        /// </summary>
+        public readonly bool End => !_moreData;
+
+        /// <summary>
+        /// The underlying <see cref="ReadOnlySequence{T}"/> for the reader.
+        /// </summary>
+        public readonly ReadOnlySequence<T> Sequence { get; }
+
+        /// <summary>
+        /// Gets the unread portion of the <see cref="Sequence"/>.
+        /// </summary>
+        /// <value>
+        /// The unread portion of the <see cref="Sequence"/>.
+        /// </value>
+        public readonly ReadOnlySequence<T> UnreadSequence => Sequence.Slice(Position);
+
+        /// <summary>
+        /// The current position in the <see cref="Sequence"/>.
+        /// </summary>
+        public readonly SequencePosition Position
+            => Sequence.GetPosition(CurrentSpanIndex, _currentPosition);
+
+        /// <summary>
+        /// The current segment in the <see cref="Sequence"/> as a span.
+        /// </summary>
+        public ReadOnlySpan<T> CurrentSpan { readonly get; private set; }
+
+        /// <summary>
+        /// The index in the <see cref="CurrentSpan"/>.
+        /// </summary>
+        public int CurrentSpanIndex { readonly get; private set; }
+
+        /// <summary>
+        /// The unread portion of the <see cref="CurrentSpan"/>.
+        /// </summary>
+        public readonly ReadOnlySpan<T> UnreadSpan
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => CurrentSpan.Slice(CurrentSpanIndex);
+        }
+
+        /// <summary>
+        /// The total number of <typeparamref name="T"/>'s processed by the reader.
+        /// </summary>
+        public long Consumed { readonly get; private set; }
+
+        /// <summary>
+        /// Remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
+        /// </summary>
+        public readonly long Remaining => Length - Consumed;
+
+        /// <summary>
+        /// Count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
+        /// </summary>
+        public readonly long Length
+        {
+            get
+            {
+                if (_length < 0)
+                {
+                    // Cast-away readonly to initialize lazy field
+                    Volatile.Write(ref Unsafe.AsRef(_length), Sequence.Length);
+                }
+                return _length;
+            }
+        }
+
+        /// <summary>
+        /// Peeks at the next value without advancing the reader.
+        /// </summary>
+        /// <param name="value">The next value or default if at the end.</param>
+        /// <returns>False if at the end of the reader.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public readonly bool TryPeek(out T value)
+        {
+            if (_moreData)
+            {
+                value = CurrentSpan[CurrentSpanIndex];
+                return true;
+            }
+            else
+            {
+                value = default;
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Peeks at the next value at specific offset without advancing the reader.
+        /// </summary>
+        /// <param name="offset">The offset from current position.</param>
+        /// <param name="value">The next value, or the default value if at the end of the reader.</param>
+        /// <returns><c>true</c> if the reader is not at its end and the peek operation succeeded; <c>false</c> if at the end of the reader.</returns>
+        public readonly bool TryPeek(long offset, out T value)
+        {
+            if (offset < 0)
+                ThrowHelper.ThrowArgumentOutOfRangeException_OffsetOutOfRange();
+
+            // If we've got data and offset is not out of bounds
+            if (!_moreData || Remaining <= offset)
+            {
+                value = default;
+                return false;
+            }
+
+            // Sum CurrentSpanIndex + offset could overflow as is but the value of offset should be very large
+            // because we check Remaining <= offset above so to overflow we should have a ReadOnlySequence close to 8 exabytes
+            Debug.Assert(CurrentSpanIndex + offset >= 0);
+
+            // If offset doesn't fall inside current segment move to next until we find correct one
+            if ((CurrentSpanIndex + offset) <= CurrentSpan.Length - 1)
+            {
+                Debug.Assert(offset <= int.MaxValue);
+
+                value = CurrentSpan[CurrentSpanIndex + (int)offset];
+                return true;
+            }
+            else
+            {
+                long remainingOffset = offset - (CurrentSpan.Length - CurrentSpanIndex);
+                SequencePosition nextPosition = _nextPosition;
+                ReadOnlyMemory<T> currentMemory = default;
+
+                while (Sequence.TryGet(ref nextPosition, out currentMemory, advance: true))
+                {
+                    // Skip empty segment
+                    if (currentMemory.Length > 0)
+                    {
+                        if (remainingOffset >= currentMemory.Length)
+                        {
+                            // Subtract current non consumed data
+                            remainingOffset -= currentMemory.Length;
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                value = currentMemory.Span[(int)remainingOffset];
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Read the next value and advance the reader.
+        /// </summary>
+        /// <param name="value">The next value or default if at the end.</param>
+        /// <returns>False if at the end of the reader.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryRead(out T value)
+        {
+            if (End)
+            {
+                value = default;
+                return false;
+            }
+
+            value = CurrentSpan[CurrentSpanIndex];
+            CurrentSpanIndex++;
+            Consumed++;
+
+            if (CurrentSpanIndex >= CurrentSpan.Length)
+            {
+                GetNextSpan();
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Move the reader back the specified number of items.
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// Thrown if trying to rewind a negative amount or more than <see cref="Consumed"/>.
+        /// </exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Rewind(long count)
+        {
+            if ((ulong)count > (ulong)Consumed)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
+            }
+
+            Consumed -= count;
+
+            if (CurrentSpanIndex >= count)
+            {
+                CurrentSpanIndex -= (int)count;
+                _moreData = true;
+            }
+            else
+            {
+                // Current segment doesn't have enough data, scan backward through segments
+                RetreatToPreviousSpan(Consumed);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void RetreatToPreviousSpan(long consumed)
+        {
+            ResetReader();
+            Advance(consumed);
+        }
+
+        private void ResetReader()
+        {
+            CurrentSpanIndex = 0;
+            Consumed = 0;
+            _currentPosition = Sequence.Start;
+            _nextPosition = _currentPosition;
+
+            if (Sequence.TryGet(ref _nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+            {
+                _moreData = true;
+
+                if (memory.Length == 0)
+                {
+                    CurrentSpan = default;
+                    // No data in the first span, move to one with data
+                    GetNextSpan();
+                }
+                else
+                {
+                    CurrentSpan = memory.Span;
+                }
+            }
+            else
+            {
+                // No data in any spans and at end of sequence
+                _moreData = false;
+                CurrentSpan = default;
+            }
+        }
+
+        /// <summary>
+        /// Get the next segment with available data, if any.
+        /// </summary>
+        private void GetNextSpan()
+        {
+            if (!Sequence.IsSingleSegment)
+            {
+                SequencePosition previousNextPosition = _nextPosition;
+                while (Sequence.TryGet(ref _nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+                {
+                    _currentPosition = previousNextPosition;
+                    if (memory.Length > 0)
+                    {
+                        CurrentSpan = memory.Span;
+                        CurrentSpanIndex = 0;
+                        return;
+                    }
+                    else
+                    {
+                        CurrentSpan = default;
+                        CurrentSpanIndex = 0;
+                        previousNextPosition = _nextPosition;
+                    }
+                }
+            }
+            _moreData = false;
+        }
+
+        /// <summary>
+        /// Move the reader ahead the specified number of items.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Advance(long count)
+        {
+            const long TooBigOrNegative = unchecked((long)0xFFFFFFFF80000000);
+            if ((count & TooBigOrNegative) == 0 && CurrentSpan.Length - CurrentSpanIndex > (int)count)
+            {
+                CurrentSpanIndex += (int)count;
+                Consumed += count;
+            }
+            else
+            {
+                // Can't satisfy from the current span
+                AdvanceToNextSpan(count);
+            }
+        }
+
+        /// <summary>
+        /// Unchecked helper to avoid unnecessary checks where you know count is valid.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void AdvanceCurrentSpan(long count)
+        {
+            Debug.Assert(count >= 0);
+
+            Consumed += count;
+            CurrentSpanIndex += (int)count;
+            if (CurrentSpanIndex >= CurrentSpan.Length)
+                GetNextSpan();
+        }
+
+        /// <summary>
+        /// Only call this helper if you know that you are advancing in the current span
+        /// with valid count and there is no need to fetch the next one.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void AdvanceWithinSpan(long count)
+        {
+            Debug.Assert(count >= 0);
+
+            Consumed += count;
+            CurrentSpanIndex += (int)count;
+
+            Debug.Assert(CurrentSpanIndex < CurrentSpan.Length);
+        }
+
+        private void AdvanceToNextSpan(long count)
+        {
+            if (count < 0)
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
+            }
+
+            Consumed += count;
+            while (_moreData)
+            {
+                int remaining = CurrentSpan.Length - CurrentSpanIndex;
+
+                if (remaining > count)
+                {
+                    CurrentSpanIndex += (int)count;
+                    count = 0;
+                    break;
+                }
+
+                // As there may not be any further segments we need to
+                // push the current index to the end of the span.
+                CurrentSpanIndex += remaining;
+                count -= remaining;
+                Debug.Assert(count >= 0);
+
+                GetNextSpan();
+
+                if (count == 0)
+                {
+                    break;
+                }
+            }
+
+            if (count != 0)
+            {
+                // Not enough data left- adjust for where we actually ended and throw
+                Consumed -= count;
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
+            }
+        }
+
+        /// <summary>
+        /// Copies data from the current <see cref="Position"/> to the given <paramref name="destination"/> span if there
+        /// is enough data to fill it.
+        /// </summary>
+        /// <remarks>
+        /// This API is used to copy a fixed amount of data out of the sequence if possible. It does not advance
+        /// the reader. To look ahead for a specific stream of data <see cref="IsNext(ReadOnlySpan{T}, bool)"/> can be used.
+        /// </remarks>
+        /// <param name="destination">Destination span to copy to.</param>
+        /// <returns>True if there is enough data to completely fill the <paramref name="destination"/> span.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public readonly bool TryCopyTo(Span<T> destination)
+        {
+            // This API doesn't advance to facilitate conditional advancement based on the data returned.
+            // We don't provide an advance option to allow easier utilizing of stack allocated destination spans.
+            // (Because we can make this method readonly we can guarantee that we won't capture the span.)
+
+            ReadOnlySpan<T> firstSpan = UnreadSpan;
+            if (firstSpan.Length >= destination.Length)
+            {
+                firstSpan.Slice(0, destination.Length).CopyTo(destination);
+                return true;
+            }
+
+            // Not enough in the current span to satisfy the request, fall through to the slow path
+            return TryCopyMultisegment(destination);
+        }
+
+        internal readonly bool TryCopyMultisegment(Span<T> destination)
+        {
+            // If we don't have enough to fill the requested buffer, return false
+            if (Remaining < destination.Length)
+                return false;
+
+            ReadOnlySpan<T> firstSpan = UnreadSpan;
+            Debug.Assert(firstSpan.Length < destination.Length);
+            firstSpan.CopyTo(destination);
+            int copied = firstSpan.Length;
+
+            SequencePosition next = _nextPosition;
+            while (Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
+            {
+                if (nextSegment.Length > 0)
+                {
+                    ReadOnlySpan<T> nextSpan = nextSegment.Span;
+                    int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);
+                    nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));
+                    copied += toCopy;
+                    if (copied >= destination.Length)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return true;
+        }
+    }
+}
\ No newline at end of file

From 8b5e1ee4a73a8075acdbdb3fd7fdb701465c617f Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 4 May 2020 19:00:07 +0900
Subject: [PATCH 02/82] Format code before import MsgPack C# customization.

---
 src/MsgPack.Abstraction/BlockReader`1.cs | 174 +++++++++++------------
 1 file changed, 87 insertions(+), 87 deletions(-)

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
index f7a1b8efd..d46e95ec4 100644
--- a/src/MsgPack.Abstraction/BlockReader`1.cs
+++ b/src/MsgPack.Abstraction/BlockReader`1.cs
@@ -22,27 +22,27 @@ namespace System.Buffers
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public SequenceReader(ReadOnlySequence<T> sequence)
         {
-            CurrentSpanIndex = 0;
-            Consumed = 0;
-            Sequence = sequence;
-            _currentPosition = sequence.Start;
-            _length = -1;
+            this.CurrentSpanIndex = 0;
+            this.Consumed = 0;
+            this.Sequence = sequence;
+            this._currentPosition = sequence.Start;
+            this._length = -1;
 
-            sequence.GetFirstSpan(out ReadOnlySpan<T> first, out _nextPosition);
-            CurrentSpan = first;
-            _moreData = first.Length > 0;
+            sequence.GetFirstSpan(out ReadOnlySpan<T> first, out this._nextPosition);
+            this.CurrentSpan = first;
+            this._moreData = first.Length > 0;
 
-            if (!_moreData && !sequence.IsSingleSegment)
+            if (!this._moreData && !sequence.IsSingleSegment)
             {
-                _moreData = true;
-                GetNextSpan();
+                this._moreData = true;
+                this.GetNextSpan();
             }
         }
 
         /// <summary>
         /// True when there is no more data in the <see cref="Sequence"/>.
         /// </summary>
-        public readonly bool End => !_moreData;
+        public readonly bool End => !this._moreData;
 
         /// <summary>
         /// The underlying <see cref="ReadOnlySequence{T}"/> for the reader.
@@ -55,13 +55,13 @@ public SequenceReader(ReadOnlySequence<T> sequence)
         /// <value>
         /// The unread portion of the <see cref="Sequence"/>.
         /// </value>
-        public readonly ReadOnlySequence<T> UnreadSequence => Sequence.Slice(Position);
+        public readonly ReadOnlySequence<T> UnreadSequence => this.Sequence.Slice(this.Position);
 
         /// <summary>
         /// The current position in the <see cref="Sequence"/>.
         /// </summary>
         public readonly SequencePosition Position
-            => Sequence.GetPosition(CurrentSpanIndex, _currentPosition);
+            => this.Sequence.GetPosition(this.CurrentSpanIndex, this._currentPosition);
 
         /// <summary>
         /// The current segment in the <see cref="Sequence"/> as a span.
@@ -79,7 +79,7 @@ public readonly SequencePosition Position
         public readonly ReadOnlySpan<T> UnreadSpan
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => CurrentSpan.Slice(CurrentSpanIndex);
+            get => this.CurrentSpan.Slice(this.CurrentSpanIndex);
         }
 
         /// <summary>
@@ -90,7 +90,7 @@ public readonly ReadOnlySpan<T> UnreadSpan
         /// <summary>
         /// Remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
         /// </summary>
-        public readonly long Remaining => Length - Consumed;
+        public readonly long Remaining => this.Length - this.Consumed;
 
         /// <summary>
         /// Count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
@@ -99,12 +99,12 @@ public readonly long Length
         {
             get
             {
-                if (_length < 0)
+                if (this._length < 0)
                 {
                     // Cast-away readonly to initialize lazy field
-                    Volatile.Write(ref Unsafe.AsRef(_length), Sequence.Length);
+                    Volatile.Write(ref Unsafe.AsRef(this._length), this.Sequence.Length);
                 }
-                return _length;
+                return this._length;
             }
         }
 
@@ -116,9 +116,9 @@ public readonly long Length
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public readonly bool TryPeek(out T value)
         {
-            if (_moreData)
+            if (this._moreData)
             {
-                value = CurrentSpan[CurrentSpanIndex];
+                value = this.CurrentSpan[this.CurrentSpanIndex];
                 return true;
             }
             else
@@ -140,7 +140,7 @@ public readonly bool TryPeek(long offset, out T value)
                 ThrowHelper.ThrowArgumentOutOfRangeException_OffsetOutOfRange();
 
             // If we've got data and offset is not out of bounds
-            if (!_moreData || Remaining <= offset)
+            if (!this._moreData || this.Remaining <= offset)
             {
                 value = default;
                 return false;
@@ -148,23 +148,23 @@ public readonly bool TryPeek(long offset, out T value)
 
             // Sum CurrentSpanIndex + offset could overflow as is but the value of offset should be very large
             // because we check Remaining <= offset above so to overflow we should have a ReadOnlySequence close to 8 exabytes
-            Debug.Assert(CurrentSpanIndex + offset >= 0);
+            Debug.Assert(this.CurrentSpanIndex + offset >= 0);
 
             // If offset doesn't fall inside current segment move to next until we find correct one
-            if ((CurrentSpanIndex + offset) <= CurrentSpan.Length - 1)
+            if ((this.CurrentSpanIndex + offset) <= this.CurrentSpan.Length - 1)
             {
                 Debug.Assert(offset <= int.MaxValue);
 
-                value = CurrentSpan[CurrentSpanIndex + (int)offset];
+                value = this.CurrentSpan[this.CurrentSpanIndex + (int)offset];
                 return true;
             }
             else
             {
-                long remainingOffset = offset - (CurrentSpan.Length - CurrentSpanIndex);
-                SequencePosition nextPosition = _nextPosition;
+                long remainingOffset = offset - (this.CurrentSpan.Length - this.CurrentSpanIndex);
+                SequencePosition nextPosition = this._nextPosition;
                 ReadOnlyMemory<T> currentMemory = default;
 
-                while (Sequence.TryGet(ref nextPosition, out currentMemory, advance: true))
+                while (this.Sequence.TryGet(ref nextPosition, out currentMemory, advance: true))
                 {
                     // Skip empty segment
                     if (currentMemory.Length > 0)
@@ -194,19 +194,19 @@ public readonly bool TryPeek(long offset, out T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool TryRead(out T value)
         {
-            if (End)
+            if (this.End)
             {
                 value = default;
                 return false;
             }
 
-            value = CurrentSpan[CurrentSpanIndex];
-            CurrentSpanIndex++;
-            Consumed++;
+            value = this.CurrentSpan[this.CurrentSpanIndex];
+            this.CurrentSpanIndex++;
+            this.Consumed++;
 
-            if (CurrentSpanIndex >= CurrentSpan.Length)
+            if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
             {
-                GetNextSpan();
+                this.GetNextSpan();
             }
 
             return true;
@@ -221,59 +221,59 @@ public bool TryRead(out T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Rewind(long count)
         {
-            if ((ulong)count > (ulong)Consumed)
+            if ((ulong)count > (ulong)this.Consumed)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
             }
 
-            Consumed -= count;
+            this.Consumed -= count;
 
-            if (CurrentSpanIndex >= count)
+            if (this.CurrentSpanIndex >= count)
             {
-                CurrentSpanIndex -= (int)count;
-                _moreData = true;
+                this.CurrentSpanIndex -= (int)count;
+                this._moreData = true;
             }
             else
             {
                 // Current segment doesn't have enough data, scan backward through segments
-                RetreatToPreviousSpan(Consumed);
+                this.RetreatToPreviousSpan(Consumed);
             }
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
         private void RetreatToPreviousSpan(long consumed)
         {
-            ResetReader();
-            Advance(consumed);
+            this.ResetReader();
+            this.Advance(consumed);
         }
 
         private void ResetReader()
         {
-            CurrentSpanIndex = 0;
-            Consumed = 0;
-            _currentPosition = Sequence.Start;
-            _nextPosition = _currentPosition;
+            this.CurrentSpanIndex = 0;
+            this.Consumed = 0;
+            this._currentPosition = this.Sequence.Start;
+            this._nextPosition = this._currentPosition;
 
-            if (Sequence.TryGet(ref _nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+            if (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
             {
-                _moreData = true;
+                this._moreData = true;
 
                 if (memory.Length == 0)
                 {
-                    CurrentSpan = default;
+                    this.CurrentSpan = default;
                     // No data in the first span, move to one with data
-                    GetNextSpan();
+                    this.GetNextSpan();
                 }
                 else
                 {
-                    CurrentSpan = memory.Span;
+                    this.CurrentSpan = memory.Span;
                 }
             }
             else
             {
                 // No data in any spans and at end of sequence
-                _moreData = false;
-                CurrentSpan = default;
+                this._moreData = false;
+                this.CurrentSpan = default;
             }
         }
 
@@ -282,27 +282,27 @@ private void ResetReader()
         /// </summary>
         private void GetNextSpan()
         {
-            if (!Sequence.IsSingleSegment)
+            if (!this.Sequence.IsSingleSegment)
             {
-                SequencePosition previousNextPosition = _nextPosition;
-                while (Sequence.TryGet(ref _nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+                SequencePosition previousNextPosition = this._nextPosition;
+                while (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
                 {
-                    _currentPosition = previousNextPosition;
+                    this._currentPosition = previousNextPosition;
                     if (memory.Length > 0)
                     {
-                        CurrentSpan = memory.Span;
-                        CurrentSpanIndex = 0;
+                        this.CurrentSpan = memory.Span;
+                        this.CurrentSpanIndex = 0;
                         return;
                     }
                     else
                     {
-                        CurrentSpan = default;
-                        CurrentSpanIndex = 0;
-                        previousNextPosition = _nextPosition;
+                        this.CurrentSpan = default;
+                        this.CurrentSpanIndex = 0;
+                        previousNextPosition = this._nextPosition;
                     }
                 }
             }
-            _moreData = false;
+            this._moreData = false;
         }
 
         /// <summary>
@@ -312,15 +312,15 @@ private void GetNextSpan()
         public void Advance(long count)
         {
             const long TooBigOrNegative = unchecked((long)0xFFFFFFFF80000000);
-            if ((count & TooBigOrNegative) == 0 && CurrentSpan.Length - CurrentSpanIndex > (int)count)
+            if ((count & TooBigOrNegative) == 0 && this.CurrentSpan.Length - this.CurrentSpanIndex > (int)count)
             {
-                CurrentSpanIndex += (int)count;
-                Consumed += count;
+                this.CurrentSpanIndex += (int)count;
+                this.Consumed += count;
             }
             else
             {
                 // Can't satisfy from the current span
-                AdvanceToNextSpan(count);
+                this.AdvanceToNextSpan(count);
             }
         }
 
@@ -332,10 +332,10 @@ internal void AdvanceCurrentSpan(long count)
         {
             Debug.Assert(count >= 0);
 
-            Consumed += count;
-            CurrentSpanIndex += (int)count;
-            if (CurrentSpanIndex >= CurrentSpan.Length)
-                GetNextSpan();
+            this.Consumed += count;
+            this.CurrentSpanIndex += (int)count;
+            if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
+                this.GetNextSpan();
         }
 
         /// <summary>
@@ -347,10 +347,10 @@ internal void AdvanceWithinSpan(long count)
         {
             Debug.Assert(count >= 0);
 
-            Consumed += count;
-            CurrentSpanIndex += (int)count;
+            this.Consumed += count;
+            this.CurrentSpanIndex += (int)count;
 
-            Debug.Assert(CurrentSpanIndex < CurrentSpan.Length);
+            Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length);
         }
 
         private void AdvanceToNextSpan(long count)
@@ -360,25 +360,25 @@ private void AdvanceToNextSpan(long count)
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
             }
 
-            Consumed += count;
-            while (_moreData)
+            this.Consumed += count;
+            while (this._moreData)
             {
-                int remaining = CurrentSpan.Length - CurrentSpanIndex;
+                int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex;
 
                 if (remaining > count)
                 {
-                    CurrentSpanIndex += (int)count;
+                    this.CurrentSpanIndex += (int)count;
                     count = 0;
                     break;
                 }
 
                 // As there may not be any further segments we need to
                 // push the current index to the end of the span.
-                CurrentSpanIndex += remaining;
+                this.CurrentSpanIndex += remaining;
                 count -= remaining;
                 Debug.Assert(count >= 0);
 
-                GetNextSpan();
+                this.GetNextSpan();
 
                 if (count == 0)
                 {
@@ -389,7 +389,7 @@ private void AdvanceToNextSpan(long count)
             if (count != 0)
             {
                 // Not enough data left- adjust for where we actually ended and throw
-                Consumed -= count;
+                this.Consumed -= count;
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
             }
         }
@@ -411,7 +411,7 @@ public readonly bool TryCopyTo(Span<T> destination)
             // We don't provide an advance option to allow easier utilizing of stack allocated destination spans.
             // (Because we can make this method readonly we can guarantee that we won't capture the span.)
 
-            ReadOnlySpan<T> firstSpan = UnreadSpan;
+            ReadOnlySpan<T> firstSpan = this.UnreadSpan;
             if (firstSpan.Length >= destination.Length)
             {
                 firstSpan.Slice(0, destination.Length).CopyTo(destination);
@@ -419,22 +419,22 @@ public readonly bool TryCopyTo(Span<T> destination)
             }
 
             // Not enough in the current span to satisfy the request, fall through to the slow path
-            return TryCopyMultisegment(destination);
+            return this.TryCopyMultisegment(destination);
         }
 
         internal readonly bool TryCopyMultisegment(Span<T> destination)
         {
             // If we don't have enough to fill the requested buffer, return false
-            if (Remaining < destination.Length)
+            if (this.Remaining < destination.Length)
                 return false;
 
-            ReadOnlySpan<T> firstSpan = UnreadSpan;
+            ReadOnlySpan<T> firstSpan = this.UnreadSpan;
             Debug.Assert(firstSpan.Length < destination.Length);
             firstSpan.CopyTo(destination);
             int copied = firstSpan.Length;
 
-            SequencePosition next = _nextPosition;
-            while (Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
+            SequencePosition next = this._nextPosition;
+            while (this.Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
             {
                 if (nextSegment.Length > 0)
                 {

From b3b8dfb23eadd8449b20803a856c39607ec30a9c Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 4 May 2020 19:01:55 +0900
Subject: [PATCH 03/82] Make SequenceReader accepting ReadOnlyMemory

This code is borrowed from MessagePack C#
---
 src/MsgPack.Abstraction/BlockReader`1.cs | 348 +++++++++++++----------
 1 file changed, 194 insertions(+), 154 deletions(-)

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
index d46e95ec4..7dde28695 100644
--- a/src/MsgPack.Abstraction/BlockReader`1.cs
+++ b/src/MsgPack.Abstraction/BlockReader`1.cs
@@ -1,110 +1,175 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/* Licensed to the .NET Foundation under one or more agreements.
+ * The .NET Foundation licenses this file to you under the MIT license.
+ * See the LICENSE file in the project root for more information. */
 
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Threading;
-using Internal.Runtime.CompilerServices;
 
 namespace System.Buffers
 {
-    public ref partial struct SequenceReader<T> where T : unmanaged, IEquatable<T>
+    internal ref partial struct SequenceReader<T>
+        where T : unmanaged, IEquatable<T>
     {
-        private SequencePosition _currentPosition;
-        private SequencePosition _nextPosition;
-        private bool _moreData;
-        private readonly long _length;
+        /// <summary>
+        /// A value indicating whether we're using <see cref="sequence"/> (as opposed to <see cref="memory"/>.
+        /// </summary>
+        private bool usingSequence;
 
         /// <summary>
-        /// Create a <see cref="SequenceReader{T}"/> over the given <see cref="ReadOnlySequence{T}"/>.
+        /// Backing for the entire sequence when we're not using <see cref="memory"/>.
+        /// </summary>
+        private ReadOnlySequence<T> sequence;
+
+        /// <summary>
+        /// The position at the start of the <see cref="CurrentSpan"/>.
+        /// </summary>
+        private SequencePosition currentPosition;
+
+        /// <summary>
+        /// The position at the end of the <see cref="CurrentSpan"/>.
+        /// </summary>
+        private SequencePosition nextPosition;
+
+        /// <summary>
+        /// Backing for the entire sequence when we're not using <see cref="sequence"/>.
+        /// </summary>
+        private ReadOnlyMemory<T> memory;
+
+        /// <summary>
+        /// A value indicating whether there is unread data remaining.
+        /// </summary>
+        private bool moreData;
+
+        /// <summary>
+        /// The total number of elements in the sequence.
+        /// </summary>
+        private long length;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
+        /// over the given <see cref="ReadOnlySequence{T}"/>.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public SequenceReader(ReadOnlySequence<T> sequence)
+        public SequenceReader(in ReadOnlySequence<T> sequence)
         {
+            this.usingSequence = true;
             this.CurrentSpanIndex = 0;
             this.Consumed = 0;
-            this.Sequence = sequence;
-            this._currentPosition = sequence.Start;
-            this._length = -1;
+            this.sequence = sequence;
+            this.memory = default;
+            this.currentPosition = sequence.Start;
+            this.length = -1;
 
-            sequence.GetFirstSpan(out ReadOnlySpan<T> first, out this._nextPosition);
+            ReadOnlySpan<T> first = sequence.First.Span;
+            this.nextPosition = sequence.GetPosition(first.Length);
             this.CurrentSpan = first;
-            this._moreData = first.Length > 0;
+            this.moreData = first.Length > 0;
 
-            if (!this._moreData && !sequence.IsSingleSegment)
+            if (!this.moreData && !sequence.IsSingleSegment)
             {
-                this._moreData = true;
+                this.moreData = true;
                 this.GetNextSpan();
             }
         }
 
         /// <summary>
-        /// True when there is no more data in the <see cref="Sequence"/>.
+        /// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
+        /// over the given <see cref="ReadOnlyMemory{T}"/>.
         /// </summary>
-        public readonly bool End => !this._moreData;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public SequenceReader(ReadOnlyMemory<T> memory)
+        {
+            this.usingSequence = false;
+            this.CurrentSpanIndex = 0;
+            this.Consumed = 0;
+            this.memory = memory;
+            this.CurrentSpan = memory.Span;
+            this.length = memory.Length;
+            this.moreData = memory.Length > 0;
+
+            this.currentPosition = default;
+            this.nextPosition = default;
+            this.sequence = default;
+        }
 
         /// <summary>
-        /// The underlying <see cref="ReadOnlySequence{T}"/> for the reader.
+        /// Gets a value indicating whether there is no more data in the <see cref="Sequence"/>.
         /// </summary>
-        public readonly ReadOnlySequence<T> Sequence { get; }
+        public bool End => !this.moreData;
 
         /// <summary>
-        /// Gets the unread portion of the <see cref="Sequence"/>.
+        /// Gets the underlying <see cref="ReadOnlySequence{T}"/> for the reader.
         /// </summary>
-        /// <value>
-        /// The unread portion of the <see cref="Sequence"/>.
-        /// </value>
-        public readonly ReadOnlySequence<T> UnreadSequence => this.Sequence.Slice(this.Position);
+        public ReadOnlySequence<T> Sequence
+        {
+            get
+            {
+                if (this.sequence.IsEmpty && !this.memory.IsEmpty)
+                {
+                    // We're in memory mode (instead of sequence mode).
+                    // Lazily fill in the sequence data.
+                    this.sequence = new ReadOnlySequence<T>(this.memory);
+                    this.currentPosition = this.sequence.Start;
+                    this.nextPosition = this.sequence.End;
+                }
+
+                return this.sequence;
+            }
+        }
 
         /// <summary>
-        /// The current position in the <see cref="Sequence"/>.
+        /// Gets the current position in the <see cref="Sequence"/>.
         /// </summary>
-        public readonly SequencePosition Position
-            => this.Sequence.GetPosition(this.CurrentSpanIndex, this._currentPosition);
+        public SequencePosition Position
+            => this.Sequence.GetPosition(this.CurrentSpanIndex, this.currentPosition);
 
         /// <summary>
-        /// The current segment in the <see cref="Sequence"/> as a span.
+        /// Gets the current segment in the <see cref="Sequence"/> as a span.
         /// </summary>
-        public ReadOnlySpan<T> CurrentSpan { readonly get; private set; }
+        public ReadOnlySpan<T> CurrentSpan { get; private set; }
 
         /// <summary>
-        /// The index in the <see cref="CurrentSpan"/>.
+        /// Gets the index in the <see cref="CurrentSpan"/>.
         /// </summary>
-        public int CurrentSpanIndex { readonly get; private set; }
+        public int CurrentSpanIndex { get; private set; }
 
         /// <summary>
-        /// The unread portion of the <see cref="CurrentSpan"/>.
+        /// Gets the unread portion of the <see cref="CurrentSpan"/>.
         /// </summary>
-        public readonly ReadOnlySpan<T> UnreadSpan
+        public ReadOnlySpan<T> UnreadSpan
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => this.CurrentSpan.Slice(this.CurrentSpanIndex);
         }
 
         /// <summary>
-        /// The total number of <typeparamref name="T"/>'s processed by the reader.
+        /// Gets the total number of <typeparamref name="T"/>'s processed by the reader.
         /// </summary>
-        public long Consumed { readonly get; private set; }
+        public long Consumed { get; private set; }
 
         /// <summary>
-        /// Remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
+        /// Gets remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
         /// </summary>
-        public readonly long Remaining => this.Length - this.Consumed;
+        public long Remaining => this.Length - this.Consumed;
 
         /// <summary>
-        /// Count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
+        /// Gets count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
         /// </summary>
-        public readonly long Length
+        public long Length
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                if (this._length < 0)
+                if (this.length < 0)
                 {
-                    // Cast-away readonly to initialize lazy field
-                    Volatile.Write(ref Unsafe.AsRef(this._length), this.Sequence.Length);
+                    // Cache the length
+                    this.length = this.Sequence.Length;
                 }
-                return this._length;
+
+                return this.length;
             }
         }
 
@@ -114,9 +179,9 @@ public readonly long Length
         /// <param name="value">The next value or default if at the end.</param>
         /// <returns>False if at the end of the reader.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public readonly bool TryPeek(out T value)
+        public bool TryPeek(out T value)
         {
-            if (this._moreData)
+            if (this.moreData)
             {
                 value = this.CurrentSpan[this.CurrentSpanIndex];
                 return true;
@@ -128,64 +193,6 @@ public readonly bool TryPeek(out T value)
             }
         }
 
-        /// <summary>
-        /// Peeks at the next value at specific offset without advancing the reader.
-        /// </summary>
-        /// <param name="offset">The offset from current position.</param>
-        /// <param name="value">The next value, or the default value if at the end of the reader.</param>
-        /// <returns><c>true</c> if the reader is not at its end and the peek operation succeeded; <c>false</c> if at the end of the reader.</returns>
-        public readonly bool TryPeek(long offset, out T value)
-        {
-            if (offset < 0)
-                ThrowHelper.ThrowArgumentOutOfRangeException_OffsetOutOfRange();
-
-            // If we've got data and offset is not out of bounds
-            if (!this._moreData || this.Remaining <= offset)
-            {
-                value = default;
-                return false;
-            }
-
-            // Sum CurrentSpanIndex + offset could overflow as is but the value of offset should be very large
-            // because we check Remaining <= offset above so to overflow we should have a ReadOnlySequence close to 8 exabytes
-            Debug.Assert(this.CurrentSpanIndex + offset >= 0);
-
-            // If offset doesn't fall inside current segment move to next until we find correct one
-            if ((this.CurrentSpanIndex + offset) <= this.CurrentSpan.Length - 1)
-            {
-                Debug.Assert(offset <= int.MaxValue);
-
-                value = this.CurrentSpan[this.CurrentSpanIndex + (int)offset];
-                return true;
-            }
-            else
-            {
-                long remainingOffset = offset - (this.CurrentSpan.Length - this.CurrentSpanIndex);
-                SequencePosition nextPosition = this._nextPosition;
-                ReadOnlyMemory<T> currentMemory = default;
-
-                while (this.Sequence.TryGet(ref nextPosition, out currentMemory, advance: true))
-                {
-                    // Skip empty segment
-                    if (currentMemory.Length > 0)
-                    {
-                        if (remainingOffset >= currentMemory.Length)
-                        {
-                            // Subtract current non consumed data
-                            remainingOffset -= currentMemory.Length;
-                        }
-                        else
-                        {
-                            break;
-                        }
-                    }
-                }
-
-                value = currentMemory.Span[(int)remainingOffset];
-                return true;
-            }
-        }
-
         /// <summary>
         /// Read the next value and advance the reader.
         /// </summary>
@@ -206,7 +213,14 @@ public bool TryRead(out T value)
 
             if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
             {
-                this.GetNextSpan();
+                if (this.usingSequence)
+                {
+                    this.GetNextSpan();
+                }
+                else
+                {
+                    this.moreData = false;
+                }
             }
 
             return true;
@@ -215,15 +229,12 @@ public bool TryRead(out T value)
         /// <summary>
         /// Move the reader back the specified number of items.
         /// </summary>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown if trying to rewind a negative amount or more than <see cref="Consumed"/>.
-        /// </exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Rewind(long count)
         {
-            if ((ulong)count > (ulong)this.Consumed)
+            if (count < 0)
             {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
+                throw new ArgumentOutOfRangeException(nameof(count));
             }
 
             this.Consumed -= count;
@@ -231,36 +242,43 @@ public void Rewind(long count)
             if (this.CurrentSpanIndex >= count)
             {
                 this.CurrentSpanIndex -= (int)count;
-                this._moreData = true;
+                this.moreData = true;
             }
-            else
+            else if (this.usingSequence)
             {
                 // Current segment doesn't have enough data, scan backward through segments
-                this.RetreatToPreviousSpan(Consumed);
+                this.RetreatToPreviousSpan(this.Consumed);
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException("Rewind went past the start of the memory.");
             }
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
         private void RetreatToPreviousSpan(long consumed)
         {
+            Debug.Assert(this.usingSequence, "usingSequence");
             this.ResetReader();
             this.Advance(consumed);
         }
 
         private void ResetReader()
         {
+            Debug.Assert(this.usingSequence, "usingSequence");
             this.CurrentSpanIndex = 0;
             this.Consumed = 0;
-            this._currentPosition = this.Sequence.Start;
-            this._nextPosition = this._currentPosition;
+            this.currentPosition = this.Sequence.Start;
+            this.nextPosition = this.currentPosition;
 
-            if (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+            if (this.Sequence.TryGet(ref this.nextPosition, out ReadOnlyMemory<T> memory, advance: true))
             {
-                this._moreData = true;
+                this.moreData = true;
 
                 if (memory.Length == 0)
                 {
                     this.CurrentSpan = default;
+
                     // No data in the first span, move to one with data
                     this.GetNextSpan();
                 }
@@ -272,7 +290,7 @@ private void ResetReader()
             else
             {
                 // No data in any spans and at end of sequence
-                this._moreData = false;
+                this.moreData = false;
                 this.CurrentSpan = default;
             }
         }
@@ -282,12 +300,13 @@ private void ResetReader()
         /// </summary>
         private void GetNextSpan()
         {
+            Debug.Assert(this.usingSequence, "usingSequence");
             if (!this.Sequence.IsSingleSegment)
             {
-                SequencePosition previousNextPosition = this._nextPosition;
-                while (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+                SequencePosition previousNextPosition = this.nextPosition;
+                while (this.Sequence.TryGet(ref this.nextPosition, out ReadOnlyMemory<T> memory, advance: true))
                 {
-                    this._currentPosition = previousNextPosition;
+                    this.currentPosition = previousNextPosition;
                     if (memory.Length > 0)
                     {
                         this.CurrentSpan = memory.Span;
@@ -298,11 +317,12 @@ private void GetNextSpan()
                     {
                         this.CurrentSpan = default;
                         this.CurrentSpanIndex = 0;
-                        previousNextPosition = this._nextPosition;
+                        previousNextPosition = this.nextPosition;
                     }
                 }
             }
-            this._moreData = false;
+
+            this.moreData = false;
         }
 
         /// <summary>
@@ -317,11 +337,21 @@ public void Advance(long count)
                 this.CurrentSpanIndex += (int)count;
                 this.Consumed += count;
             }
-            else
+            else if (this.usingSequence)
             {
                 // Can't satisfy from the current span
                 this.AdvanceToNextSpan(count);
             }
+            else if (this.CurrentSpan.Length - this.CurrentSpanIndex == (int)count)
+            {
+                this.CurrentSpanIndex += (int)count;
+                this.Consumed += count;
+                this.moreData = false;
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException(nameof(count));
+            }
         }
 
         /// <summary>
@@ -330,12 +360,14 @@ public void Advance(long count)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void AdvanceCurrentSpan(long count)
         {
-            Debug.Assert(count >= 0);
+            Debug.Assert(count >= 0, "count >= 0");
 
             this.Consumed += count;
             this.CurrentSpanIndex += (int)count;
-            if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
+            if (this.usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length)
+            {
                 this.GetNextSpan();
+            }
         }
 
         /// <summary>
@@ -345,23 +377,40 @@ internal void AdvanceCurrentSpan(long count)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void AdvanceWithinSpan(long count)
         {
-            Debug.Assert(count >= 0);
+            Debug.Assert(count >= 0, "count >= 0");
 
             this.Consumed += count;
             this.CurrentSpanIndex += (int)count;
 
-            Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length);
+            Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length, "this.CurrentSpanIndex < this.CurrentSpan.Length");
+        }
+
+        /// <summary>
+        /// Move the reader ahead the specified number of items
+        /// if there are enough elements remaining in the sequence.
+        /// </summary>
+        /// <returns><c>true</c> if there were enough elements to advance; otherwise <c>false</c>.</returns>
+        internal bool TryAdvance(long count)
+        {
+            if (this.Remaining < count)
+            {
+                return false;
+            }
+
+            this.Advance(count);
+            return true;
         }
 
         private void AdvanceToNextSpan(long count)
         {
+            Debug.Assert(this.usingSequence, "usingSequence");
             if (count < 0)
             {
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
+                throw new ArgumentOutOfRangeException(nameof(count));
             }
 
             this.Consumed += count;
-            while (this._moreData)
+            while (this.moreData)
             {
                 int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex;
 
@@ -376,7 +425,7 @@ private void AdvanceToNextSpan(long count)
                 // push the current index to the end of the span.
                 this.CurrentSpanIndex += remaining;
                 count -= remaining;
-                Debug.Assert(count >= 0);
+                Debug.Assert(count >= 0, "count >= 0");
 
                 this.GetNextSpan();
 
@@ -390,27 +439,18 @@ private void AdvanceToNextSpan(long count)
             {
                 // Not enough data left- adjust for where we actually ended and throw
                 this.Consumed -= count;
-                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
+                throw new ArgumentOutOfRangeException(nameof(count));
             }
         }
 
         /// <summary>
-        /// Copies data from the current <see cref="Position"/> to the given <paramref name="destination"/> span if there
-        /// is enough data to fill it.
+        /// Copies data from the current <see cref="Position"/> to the given <paramref name="destination"/> span.
         /// </summary>
-        /// <remarks>
-        /// This API is used to copy a fixed amount of data out of the sequence if possible. It does not advance
-        /// the reader. To look ahead for a specific stream of data <see cref="IsNext(ReadOnlySpan{T}, bool)"/> can be used.
-        /// </remarks>
-        /// <param name="destination">Destination span to copy to.</param>
-        /// <returns>True if there is enough data to completely fill the <paramref name="destination"/> span.</returns>
+        /// <param name="destination">Destination to copy to.</param>
+        /// <returns>True if there is enough data to copy to the <paramref name="destination"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public readonly bool TryCopyTo(Span<T> destination)
+        public bool TryCopyTo(Span<T> destination)
         {
-            // This API doesn't advance to facilitate conditional advancement based on the data returned.
-            // We don't provide an advance option to allow easier utilizing of stack allocated destination spans.
-            // (Because we can make this method readonly we can guarantee that we won't capture the span.)
-
             ReadOnlySpan<T> firstSpan = this.UnreadSpan;
             if (firstSpan.Length >= destination.Length)
             {
@@ -418,22 +458,22 @@ public readonly bool TryCopyTo(Span<T> destination)
                 return true;
             }
 
-            // Not enough in the current span to satisfy the request, fall through to the slow path
             return this.TryCopyMultisegment(destination);
         }
 
-        internal readonly bool TryCopyMultisegment(Span<T> destination)
+        internal bool TryCopyMultisegment(Span<T> destination)
         {
-            // If we don't have enough to fill the requested buffer, return false
             if (this.Remaining < destination.Length)
+            {
                 return false;
+            }
 
             ReadOnlySpan<T> firstSpan = this.UnreadSpan;
-            Debug.Assert(firstSpan.Length < destination.Length);
+            Debug.Assert(firstSpan.Length < destination.Length, "firstSpan.Length < destination.Length");
             firstSpan.CopyTo(destination);
             int copied = firstSpan.Length;
 
-            SequencePosition next = this._nextPosition;
+            SequencePosition next = this.nextPosition;
             while (this.Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
             {
                 if (nextSegment.Length > 0)
@@ -452,4 +492,4 @@ internal readonly bool TryCopyMultisegment(Span<T> destination)
             return true;
         }
     }
-}
\ No newline at end of file
+}

From 808cb93668862948dcc4775448cb15af45f40c51 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 4 May 2020 19:07:18 +0900
Subject: [PATCH 04/82] Fix code format before more customization.

---
 src/MsgPack.Abstraction/BlockReader`1.cs | 122 +++++++++++------------
 1 file changed, 61 insertions(+), 61 deletions(-)

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
index 7dde28695..4ecd9ccfe 100644
--- a/src/MsgPack.Abstraction/BlockReader`1.cs
+++ b/src/MsgPack.Abstraction/BlockReader`1.cs
@@ -14,39 +14,39 @@ internal ref partial struct SequenceReader<T>
         where T : unmanaged, IEquatable<T>
     {
         /// <summary>
-        /// A value indicating whether we're using <see cref="sequence"/> (as opposed to <see cref="memory"/>.
+        /// A value indicating whether we're using <see cref="_sequence"/> (as opposed to <see cref="_memory"/>.
         /// </summary>
-        private bool usingSequence;
+        private readonly bool _usingSequence;
 
         /// <summary>
-        /// Backing for the entire sequence when we're not using <see cref="memory"/>.
+        /// Backing for the entire sequence when we're not using <see cref="_memory"/>.
         /// </summary>
-        private ReadOnlySequence<T> sequence;
+        private ReadOnlySequence<T> _sequence;
 
         /// <summary>
         /// The position at the start of the <see cref="CurrentSpan"/>.
         /// </summary>
-        private SequencePosition currentPosition;
+        private SequencePosition _currentPosition;
 
         /// <summary>
         /// The position at the end of the <see cref="CurrentSpan"/>.
         /// </summary>
-        private SequencePosition nextPosition;
+        private SequencePosition _nextPosition;
 
         /// <summary>
-        /// Backing for the entire sequence when we're not using <see cref="sequence"/>.
+        /// Backing for the entire sequence when we're not using <see cref="_sequence"/>.
         /// </summary>
-        private ReadOnlyMemory<T> memory;
+        private readonly ReadOnlyMemory<T> _memory;
 
         /// <summary>
         /// A value indicating whether there is unread data remaining.
         /// </summary>
-        private bool moreData;
+        private bool _moreData;
 
         /// <summary>
         /// The total number of elements in the sequence.
         /// </summary>
-        private long length;
+        private long _length;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
@@ -55,22 +55,22 @@ internal ref partial struct SequenceReader<T>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public SequenceReader(in ReadOnlySequence<T> sequence)
         {
-            this.usingSequence = true;
+            this._usingSequence = true;
             this.CurrentSpanIndex = 0;
             this.Consumed = 0;
-            this.sequence = sequence;
-            this.memory = default;
-            this.currentPosition = sequence.Start;
-            this.length = -1;
+            this._sequence = sequence;
+            this._memory = default;
+            this._currentPosition = sequence.Start;
+            this._length = -1;
 
             ReadOnlySpan<T> first = sequence.First.Span;
-            this.nextPosition = sequence.GetPosition(first.Length);
+            this._nextPosition = sequence.GetPosition(first.Length);
             this.CurrentSpan = first;
-            this.moreData = first.Length > 0;
+            this._moreData = first.Length > 0;
 
-            if (!this.moreData && !sequence.IsSingleSegment)
+            if (!this._moreData && !sequence.IsSingleSegment)
             {
-                this.moreData = true;
+                this._moreData = true;
                 this.GetNextSpan();
             }
         }
@@ -82,23 +82,23 @@ public SequenceReader(in ReadOnlySequence<T> sequence)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public SequenceReader(ReadOnlyMemory<T> memory)
         {
-            this.usingSequence = false;
+            this._usingSequence = false;
             this.CurrentSpanIndex = 0;
             this.Consumed = 0;
-            this.memory = memory;
+            this._memory = memory;
             this.CurrentSpan = memory.Span;
-            this.length = memory.Length;
-            this.moreData = memory.Length > 0;
+            this._length = memory.Length;
+            this._moreData = memory.Length > 0;
 
-            this.currentPosition = default;
-            this.nextPosition = default;
-            this.sequence = default;
+            this._currentPosition = default;
+            this._nextPosition = default;
+            this._sequence = default;
         }
 
         /// <summary>
         /// Gets a value indicating whether there is no more data in the <see cref="Sequence"/>.
         /// </summary>
-        public bool End => !this.moreData;
+        public bool End => !this._moreData;
 
         /// <summary>
         /// Gets the underlying <see cref="ReadOnlySequence{T}"/> for the reader.
@@ -107,16 +107,16 @@ public ReadOnlySequence<T> Sequence
         {
             get
             {
-                if (this.sequence.IsEmpty && !this.memory.IsEmpty)
+                if (this._sequence.IsEmpty && !this._memory.IsEmpty)
                 {
                     // We're in memory mode (instead of sequence mode).
                     // Lazily fill in the sequence data.
-                    this.sequence = new ReadOnlySequence<T>(this.memory);
-                    this.currentPosition = this.sequence.Start;
-                    this.nextPosition = this.sequence.End;
+                    this._sequence = new ReadOnlySequence<T>(this._memory);
+                    this._currentPosition = this._sequence.Start;
+                    this._nextPosition = this._sequence.End;
                 }
 
-                return this.sequence;
+                return this._sequence;
             }
         }
 
@@ -124,7 +124,7 @@ public ReadOnlySequence<T> Sequence
         /// Gets the current position in the <see cref="Sequence"/>.
         /// </summary>
         public SequencePosition Position
-            => this.Sequence.GetPosition(this.CurrentSpanIndex, this.currentPosition);
+            => this.Sequence.GetPosition(this.CurrentSpanIndex, this._currentPosition);
 
         /// <summary>
         /// Gets the current segment in the <see cref="Sequence"/> as a span.
@@ -163,13 +163,13 @@ public long Length
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                if (this.length < 0)
+                if (this._length < 0)
                 {
                     // Cache the length
-                    this.length = this.Sequence.Length;
+                    this._length = this.Sequence.Length;
                 }
 
-                return this.length;
+                return this._length;
             }
         }
 
@@ -181,7 +181,7 @@ public long Length
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool TryPeek(out T value)
         {
-            if (this.moreData)
+            if (this._moreData)
             {
                 value = this.CurrentSpan[this.CurrentSpanIndex];
                 return true;
@@ -213,13 +213,13 @@ public bool TryRead(out T value)
 
             if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
             {
-                if (this.usingSequence)
+                if (this._usingSequence)
                 {
                     this.GetNextSpan();
                 }
                 else
                 {
-                    this.moreData = false;
+                    this._moreData = false;
                 }
             }
 
@@ -242,9 +242,9 @@ public void Rewind(long count)
             if (this.CurrentSpanIndex >= count)
             {
                 this.CurrentSpanIndex -= (int)count;
-                this.moreData = true;
+                this._moreData = true;
             }
-            else if (this.usingSequence)
+            else if (this._usingSequence)
             {
                 // Current segment doesn't have enough data, scan backward through segments
                 this.RetreatToPreviousSpan(this.Consumed);
@@ -258,22 +258,22 @@ public void Rewind(long count)
         [MethodImpl(MethodImplOptions.NoInlining)]
         private void RetreatToPreviousSpan(long consumed)
         {
-            Debug.Assert(this.usingSequence, "usingSequence");
+            Debug.Assert(this._usingSequence, "usingSequence");
             this.ResetReader();
             this.Advance(consumed);
         }
 
         private void ResetReader()
         {
-            Debug.Assert(this.usingSequence, "usingSequence");
+            Debug.Assert(this._usingSequence, "usingSequence");
             this.CurrentSpanIndex = 0;
             this.Consumed = 0;
-            this.currentPosition = this.Sequence.Start;
-            this.nextPosition = this.currentPosition;
+            this._currentPosition = this.Sequence.Start;
+            this._nextPosition = this._currentPosition;
 
-            if (this.Sequence.TryGet(ref this.nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+            if (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
             {
-                this.moreData = true;
+                this._moreData = true;
 
                 if (memory.Length == 0)
                 {
@@ -290,7 +290,7 @@ private void ResetReader()
             else
             {
                 // No data in any spans and at end of sequence
-                this.moreData = false;
+                this._moreData = false;
                 this.CurrentSpan = default;
             }
         }
@@ -300,13 +300,13 @@ private void ResetReader()
         /// </summary>
         private void GetNextSpan()
         {
-            Debug.Assert(this.usingSequence, "usingSequence");
+            Debug.Assert(this._usingSequence, "usingSequence");
             if (!this.Sequence.IsSingleSegment)
             {
-                SequencePosition previousNextPosition = this.nextPosition;
-                while (this.Sequence.TryGet(ref this.nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+                SequencePosition previousNextPosition = this._nextPosition;
+                while (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
                 {
-                    this.currentPosition = previousNextPosition;
+                    this._currentPosition = previousNextPosition;
                     if (memory.Length > 0)
                     {
                         this.CurrentSpan = memory.Span;
@@ -317,12 +317,12 @@ private void GetNextSpan()
                     {
                         this.CurrentSpan = default;
                         this.CurrentSpanIndex = 0;
-                        previousNextPosition = this.nextPosition;
+                        previousNextPosition = this._nextPosition;
                     }
                 }
             }
 
-            this.moreData = false;
+            this._moreData = false;
         }
 
         /// <summary>
@@ -337,7 +337,7 @@ public void Advance(long count)
                 this.CurrentSpanIndex += (int)count;
                 this.Consumed += count;
             }
-            else if (this.usingSequence)
+            else if (this._usingSequence)
             {
                 // Can't satisfy from the current span
                 this.AdvanceToNextSpan(count);
@@ -346,7 +346,7 @@ public void Advance(long count)
             {
                 this.CurrentSpanIndex += (int)count;
                 this.Consumed += count;
-                this.moreData = false;
+                this._moreData = false;
             }
             else
             {
@@ -364,7 +364,7 @@ internal void AdvanceCurrentSpan(long count)
 
             this.Consumed += count;
             this.CurrentSpanIndex += (int)count;
-            if (this.usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length)
+            if (this._usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length)
             {
                 this.GetNextSpan();
             }
@@ -403,14 +403,14 @@ internal bool TryAdvance(long count)
 
         private void AdvanceToNextSpan(long count)
         {
-            Debug.Assert(this.usingSequence, "usingSequence");
+            Debug.Assert(this._usingSequence, "usingSequence");
             if (count < 0)
             {
                 throw new ArgumentOutOfRangeException(nameof(count));
             }
 
             this.Consumed += count;
-            while (this.moreData)
+            while (this._moreData)
             {
                 int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex;
 
@@ -473,7 +473,7 @@ internal bool TryCopyMultisegment(Span<T> destination)
             firstSpan.CopyTo(destination);
             int copied = firstSpan.Length;
 
-            SequencePosition next = this.nextPosition;
+            SequencePosition next = this._nextPosition;
             while (this.Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
             {
                 if (nextSegment.Length > 0)
@@ -492,4 +492,4 @@ internal bool TryCopyMultisegment(Span<T> destination)
             return true;
         }
     }
-}
+}
\ No newline at end of file

From fd8b126d2a77db97d27ac97d9122487abd451e1b Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 4 May 2020 19:08:46 +0900
Subject: [PATCH 05/82] Clarify licensing terms

---
 src/MsgPack.Abstraction/BlockReader`1.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
index 4ecd9ccfe..8ec92b2f1 100644
--- a/src/MsgPack.Abstraction/BlockReader`1.cs
+++ b/src/MsgPack.Abstraction/BlockReader`1.cs
@@ -1,6 +1,12 @@
-// Copyright (c) All contributors. All rights reserved.
+// This file is originated from MessagePack C# and .NET Core Libraries
+
+// License term of MessagePack C#:
+
+// Copyright (c) All contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+// License term of .NET Core Libraries:
+
 /* Licensed to the .NET Foundation under one or more agreements.
  * The .NET Foundation licenses this file to you under the MIT license.
  * See the LICENSE file in the project root for more information. */

From 4b0bf12db42e81612e5de6a27fdb9433ccf9ef0d Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 4 May 2020 19:17:00 +0900
Subject: [PATCH 06/82] Code formatting

---
 src/MsgPack.Abstraction/BlockReader`1.cs | 966 +++++++++++------------
 1 file changed, 483 insertions(+), 483 deletions(-)

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
index 8ec92b2f1..be0b27f21 100644
--- a/src/MsgPack.Abstraction/BlockReader`1.cs
+++ b/src/MsgPack.Abstraction/BlockReader`1.cs
@@ -16,486 +16,486 @@
 
 namespace System.Buffers
 {
-    internal ref partial struct SequenceReader<T>
-        where T : unmanaged, IEquatable<T>
-    {
-        /// <summary>
-        /// A value indicating whether we're using <see cref="_sequence"/> (as opposed to <see cref="_memory"/>.
-        /// </summary>
-        private readonly bool _usingSequence;
-
-        /// <summary>
-        /// Backing for the entire sequence when we're not using <see cref="_memory"/>.
-        /// </summary>
-        private ReadOnlySequence<T> _sequence;
-
-        /// <summary>
-        /// The position at the start of the <see cref="CurrentSpan"/>.
-        /// </summary>
-        private SequencePosition _currentPosition;
-
-        /// <summary>
-        /// The position at the end of the <see cref="CurrentSpan"/>.
-        /// </summary>
-        private SequencePosition _nextPosition;
-
-        /// <summary>
-        /// Backing for the entire sequence when we're not using <see cref="_sequence"/>.
-        /// </summary>
-        private readonly ReadOnlyMemory<T> _memory;
-
-        /// <summary>
-        /// A value indicating whether there is unread data remaining.
-        /// </summary>
-        private bool _moreData;
-
-        /// <summary>
-        /// The total number of elements in the sequence.
-        /// </summary>
-        private long _length;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
-        /// over the given <see cref="ReadOnlySequence{T}"/>.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public SequenceReader(in ReadOnlySequence<T> sequence)
-        {
-            this._usingSequence = true;
-            this.CurrentSpanIndex = 0;
-            this.Consumed = 0;
-            this._sequence = sequence;
-            this._memory = default;
-            this._currentPosition = sequence.Start;
-            this._length = -1;
-
-            ReadOnlySpan<T> first = sequence.First.Span;
-            this._nextPosition = sequence.GetPosition(first.Length);
-            this.CurrentSpan = first;
-            this._moreData = first.Length > 0;
-
-            if (!this._moreData && !sequence.IsSingleSegment)
-            {
-                this._moreData = true;
-                this.GetNextSpan();
-            }
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
-        /// over the given <see cref="ReadOnlyMemory{T}"/>.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public SequenceReader(ReadOnlyMemory<T> memory)
-        {
-            this._usingSequence = false;
-            this.CurrentSpanIndex = 0;
-            this.Consumed = 0;
-            this._memory = memory;
-            this.CurrentSpan = memory.Span;
-            this._length = memory.Length;
-            this._moreData = memory.Length > 0;
-
-            this._currentPosition = default;
-            this._nextPosition = default;
-            this._sequence = default;
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether there is no more data in the <see cref="Sequence"/>.
-        /// </summary>
-        public bool End => !this._moreData;
-
-        /// <summary>
-        /// Gets the underlying <see cref="ReadOnlySequence{T}"/> for the reader.
-        /// </summary>
-        public ReadOnlySequence<T> Sequence
-        {
-            get
-            {
-                if (this._sequence.IsEmpty && !this._memory.IsEmpty)
-                {
-                    // We're in memory mode (instead of sequence mode).
-                    // Lazily fill in the sequence data.
-                    this._sequence = new ReadOnlySequence<T>(this._memory);
-                    this._currentPosition = this._sequence.Start;
-                    this._nextPosition = this._sequence.End;
-                }
-
-                return this._sequence;
-            }
-        }
-
-        /// <summary>
-        /// Gets the current position in the <see cref="Sequence"/>.
-        /// </summary>
-        public SequencePosition Position
-            => this.Sequence.GetPosition(this.CurrentSpanIndex, this._currentPosition);
-
-        /// <summary>
-        /// Gets the current segment in the <see cref="Sequence"/> as a span.
-        /// </summary>
-        public ReadOnlySpan<T> CurrentSpan { get; private set; }
-
-        /// <summary>
-        /// Gets the index in the <see cref="CurrentSpan"/>.
-        /// </summary>
-        public int CurrentSpanIndex { get; private set; }
-
-        /// <summary>
-        /// Gets the unread portion of the <see cref="CurrentSpan"/>.
-        /// </summary>
-        public ReadOnlySpan<T> UnreadSpan
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => this.CurrentSpan.Slice(this.CurrentSpanIndex);
-        }
-
-        /// <summary>
-        /// Gets the total number of <typeparamref name="T"/>'s processed by the reader.
-        /// </summary>
-        public long Consumed { get; private set; }
-
-        /// <summary>
-        /// Gets remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
-        /// </summary>
-        public long Remaining => this.Length - this.Consumed;
-
-        /// <summary>
-        /// Gets count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
-        /// </summary>
-        public long Length
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                if (this._length < 0)
-                {
-                    // Cache the length
-                    this._length = this.Sequence.Length;
-                }
-
-                return this._length;
-            }
-        }
-
-        /// <summary>
-        /// Peeks at the next value without advancing the reader.
-        /// </summary>
-        /// <param name="value">The next value or default if at the end.</param>
-        /// <returns>False if at the end of the reader.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryPeek(out T value)
-        {
-            if (this._moreData)
-            {
-                value = this.CurrentSpan[this.CurrentSpanIndex];
-                return true;
-            }
-            else
-            {
-                value = default;
-                return false;
-            }
-        }
-
-        /// <summary>
-        /// Read the next value and advance the reader.
-        /// </summary>
-        /// <param name="value">The next value or default if at the end.</param>
-        /// <returns>False if at the end of the reader.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryRead(out T value)
-        {
-            if (this.End)
-            {
-                value = default;
-                return false;
-            }
-
-            value = this.CurrentSpan[this.CurrentSpanIndex];
-            this.CurrentSpanIndex++;
-            this.Consumed++;
-
-            if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
-            {
-                if (this._usingSequence)
-                {
-                    this.GetNextSpan();
-                }
-                else
-                {
-                    this._moreData = false;
-                }
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Move the reader back the specified number of items.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Rewind(long count)
-        {
-            if (count < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(count));
-            }
-
-            this.Consumed -= count;
-
-            if (this.CurrentSpanIndex >= count)
-            {
-                this.CurrentSpanIndex -= (int)count;
-                this._moreData = true;
-            }
-            else if (this._usingSequence)
-            {
-                // Current segment doesn't have enough data, scan backward through segments
-                this.RetreatToPreviousSpan(this.Consumed);
-            }
-            else
-            {
-                throw new ArgumentOutOfRangeException("Rewind went past the start of the memory.");
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void RetreatToPreviousSpan(long consumed)
-        {
-            Debug.Assert(this._usingSequence, "usingSequence");
-            this.ResetReader();
-            this.Advance(consumed);
-        }
-
-        private void ResetReader()
-        {
-            Debug.Assert(this._usingSequence, "usingSequence");
-            this.CurrentSpanIndex = 0;
-            this.Consumed = 0;
-            this._currentPosition = this.Sequence.Start;
-            this._nextPosition = this._currentPosition;
-
-            if (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
-            {
-                this._moreData = true;
-
-                if (memory.Length == 0)
-                {
-                    this.CurrentSpan = default;
-
-                    // No data in the first span, move to one with data
-                    this.GetNextSpan();
-                }
-                else
-                {
-                    this.CurrentSpan = memory.Span;
-                }
-            }
-            else
-            {
-                // No data in any spans and at end of sequence
-                this._moreData = false;
-                this.CurrentSpan = default;
-            }
-        }
-
-        /// <summary>
-        /// Get the next segment with available data, if any.
-        /// </summary>
-        private void GetNextSpan()
-        {
-            Debug.Assert(this._usingSequence, "usingSequence");
-            if (!this.Sequence.IsSingleSegment)
-            {
-                SequencePosition previousNextPosition = this._nextPosition;
-                while (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
-                {
-                    this._currentPosition = previousNextPosition;
-                    if (memory.Length > 0)
-                    {
-                        this.CurrentSpan = memory.Span;
-                        this.CurrentSpanIndex = 0;
-                        return;
-                    }
-                    else
-                    {
-                        this.CurrentSpan = default;
-                        this.CurrentSpanIndex = 0;
-                        previousNextPosition = this._nextPosition;
-                    }
-                }
-            }
-
-            this._moreData = false;
-        }
-
-        /// <summary>
-        /// Move the reader ahead the specified number of items.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Advance(long count)
-        {
-            const long TooBigOrNegative = unchecked((long)0xFFFFFFFF80000000);
-            if ((count & TooBigOrNegative) == 0 && this.CurrentSpan.Length - this.CurrentSpanIndex > (int)count)
-            {
-                this.CurrentSpanIndex += (int)count;
-                this.Consumed += count;
-            }
-            else if (this._usingSequence)
-            {
-                // Can't satisfy from the current span
-                this.AdvanceToNextSpan(count);
-            }
-            else if (this.CurrentSpan.Length - this.CurrentSpanIndex == (int)count)
-            {
-                this.CurrentSpanIndex += (int)count;
-                this.Consumed += count;
-                this._moreData = false;
-            }
-            else
-            {
-                throw new ArgumentOutOfRangeException(nameof(count));
-            }
-        }
-
-        /// <summary>
-        /// Unchecked helper to avoid unnecessary checks where you know count is valid.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void AdvanceCurrentSpan(long count)
-        {
-            Debug.Assert(count >= 0, "count >= 0");
-
-            this.Consumed += count;
-            this.CurrentSpanIndex += (int)count;
-            if (this._usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length)
-            {
-                this.GetNextSpan();
-            }
-        }
-
-        /// <summary>
-        /// Only call this helper if you know that you are advancing in the current span
-        /// with valid count and there is no need to fetch the next one.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void AdvanceWithinSpan(long count)
-        {
-            Debug.Assert(count >= 0, "count >= 0");
-
-            this.Consumed += count;
-            this.CurrentSpanIndex += (int)count;
-
-            Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length, "this.CurrentSpanIndex < this.CurrentSpan.Length");
-        }
-
-        /// <summary>
-        /// Move the reader ahead the specified number of items
-        /// if there are enough elements remaining in the sequence.
-        /// </summary>
-        /// <returns><c>true</c> if there were enough elements to advance; otherwise <c>false</c>.</returns>
-        internal bool TryAdvance(long count)
-        {
-            if (this.Remaining < count)
-            {
-                return false;
-            }
-
-            this.Advance(count);
-            return true;
-        }
-
-        private void AdvanceToNextSpan(long count)
-        {
-            Debug.Assert(this._usingSequence, "usingSequence");
-            if (count < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(count));
-            }
-
-            this.Consumed += count;
-            while (this._moreData)
-            {
-                int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex;
-
-                if (remaining > count)
-                {
-                    this.CurrentSpanIndex += (int)count;
-                    count = 0;
-                    break;
-                }
-
-                // As there may not be any further segments we need to
-                // push the current index to the end of the span.
-                this.CurrentSpanIndex += remaining;
-                count -= remaining;
-                Debug.Assert(count >= 0, "count >= 0");
-
-                this.GetNextSpan();
-
-                if (count == 0)
-                {
-                    break;
-                }
-            }
-
-            if (count != 0)
-            {
-                // Not enough data left- adjust for where we actually ended and throw
-                this.Consumed -= count;
-                throw new ArgumentOutOfRangeException(nameof(count));
-            }
-        }
-
-        /// <summary>
-        /// Copies data from the current <see cref="Position"/> to the given <paramref name="destination"/> span.
-        /// </summary>
-        /// <param name="destination">Destination to copy to.</param>
-        /// <returns>True if there is enough data to copy to the <paramref name="destination"/>.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryCopyTo(Span<T> destination)
-        {
-            ReadOnlySpan<T> firstSpan = this.UnreadSpan;
-            if (firstSpan.Length >= destination.Length)
-            {
-                firstSpan.Slice(0, destination.Length).CopyTo(destination);
-                return true;
-            }
-
-            return this.TryCopyMultisegment(destination);
-        }
-
-        internal bool TryCopyMultisegment(Span<T> destination)
-        {
-            if (this.Remaining < destination.Length)
-            {
-                return false;
-            }
-
-            ReadOnlySpan<T> firstSpan = this.UnreadSpan;
-            Debug.Assert(firstSpan.Length < destination.Length, "firstSpan.Length < destination.Length");
-            firstSpan.CopyTo(destination);
-            int copied = firstSpan.Length;
-
-            SequencePosition next = this._nextPosition;
-            while (this.Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
-            {
-                if (nextSegment.Length > 0)
-                {
-                    ReadOnlySpan<T> nextSpan = nextSegment.Span;
-                    int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);
-                    nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));
-                    copied += toCopy;
-                    if (copied >= destination.Length)
-                    {
-                        break;
-                    }
-                }
-            }
-
-            return true;
-        }
-    }
-}
\ No newline at end of file
+	internal ref partial struct SequenceReader<T>
+		where T : unmanaged, IEquatable<T>
+	{
+		/// <summary>
+		/// A value indicating whether we're using <see cref="_sequence"/> (as opposed to <see cref="_memory"/>.
+		/// </summary>
+		private readonly bool _usingSequence;
+
+		/// <summary>
+		/// Backing for the entire sequence when we're not using <see cref="_memory"/>.
+		/// </summary>
+		private ReadOnlySequence<T> _sequence;
+
+		/// <summary>
+		/// The position at the start of the <see cref="CurrentSpan"/>.
+		/// </summary>
+		private SequencePosition _currentPosition;
+
+		/// <summary>
+		/// The position at the end of the <see cref="CurrentSpan"/>.
+		/// </summary>
+		private SequencePosition _nextPosition;
+
+		/// <summary>
+		/// Backing for the entire sequence when we're not using <see cref="_sequence"/>.
+		/// </summary>
+		private readonly ReadOnlyMemory<T> _memory;
+
+		/// <summary>
+		/// A value indicating whether there is unread data remaining.
+		/// </summary>
+		private bool _moreData;
+
+		/// <summary>
+		/// The total number of elements in the sequence.
+		/// </summary>
+		private long _length;
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
+		/// over the given <see cref="ReadOnlySequence{T}"/>.
+		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public SequenceReader(in ReadOnlySequence<T> sequence)
+		{
+			this._usingSequence = true;
+			this.CurrentSpanIndex = 0;
+			this.Consumed = 0;
+			this._sequence = sequence;
+			this._memory = default;
+			this._currentPosition = sequence.Start;
+			this._length = -1;
+
+			ReadOnlySpan<T> first = sequence.First.Span;
+			this._nextPosition = sequence.GetPosition(first.Length);
+			this.CurrentSpan = first;
+			this._moreData = first.Length > 0;
+
+			if (!this._moreData && !sequence.IsSingleSegment)
+			{
+				this._moreData = true;
+				this.GetNextSpan();
+			}
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
+		/// over the given <see cref="ReadOnlyMemory{T}"/>.
+		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public SequenceReader(ReadOnlyMemory<T> memory)
+		{
+			this._usingSequence = false;
+			this.CurrentSpanIndex = 0;
+			this.Consumed = 0;
+			this._memory = memory;
+			this.CurrentSpan = memory.Span;
+			this._length = memory.Length;
+			this._moreData = memory.Length > 0;
+
+			this._currentPosition = default;
+			this._nextPosition = default;
+			this._sequence = default;
+		}
+
+		/// <summary>
+		/// Gets a value indicating whether there is no more data in the <see cref="Sequence"/>.
+		/// </summary>
+		public bool End => !this._moreData;
+
+		/// <summary>
+		/// Gets the underlying <see cref="ReadOnlySequence{T}"/> for the reader.
+		/// </summary>
+		public ReadOnlySequence<T> Sequence
+		{
+			get
+			{
+				if (this._sequence.IsEmpty && !this._memory.IsEmpty)
+				{
+					// We're in memory mode (instead of sequence mode).
+					// Lazily fill in the sequence data.
+					this._sequence = new ReadOnlySequence<T>(this._memory);
+					this._currentPosition = this._sequence.Start;
+					this._nextPosition = this._sequence.End;
+				}
+
+				return this._sequence;
+			}
+		}
+
+		/// <summary>
+		/// Gets the current position in the <see cref="Sequence"/>.
+		/// </summary>
+		public SequencePosition Position
+			=> this.Sequence.GetPosition(this.CurrentSpanIndex, this._currentPosition);
+
+		/// <summary>
+		/// Gets the current segment in the <see cref="Sequence"/> as a span.
+		/// </summary>
+		public ReadOnlySpan<T> CurrentSpan { get; private set; }
+
+		/// <summary>
+		/// Gets the index in the <see cref="CurrentSpan"/>.
+		/// </summary>
+		public int CurrentSpanIndex { get; private set; }
+
+		/// <summary>
+		/// Gets the unread portion of the <see cref="CurrentSpan"/>.
+		/// </summary>
+		public ReadOnlySpan<T> UnreadSpan
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			get => this.CurrentSpan.Slice(this.CurrentSpanIndex);
+		}
+
+		/// <summary>
+		/// Gets the total number of <typeparamref name="T"/>'s processed by the reader.
+		/// </summary>
+		public long Consumed { get; private set; }
+
+		/// <summary>
+		/// Gets remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
+		/// </summary>
+		public long Remaining => this.Length - this.Consumed;
+
+		/// <summary>
+		/// Gets count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
+		/// </summary>
+		public long Length
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			get
+			{
+				if (this._length < 0)
+				{
+					// Cache the length
+					this._length = this.Sequence.Length;
+				}
+
+				return this._length;
+			}
+		}
+
+		/// <summary>
+		/// Peeks at the next value without advancing the reader.
+		/// </summary>
+		/// <param name="value">The next value or default if at the end.</param>
+		/// <returns>False if at the end of the reader.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool TryPeek(out T value)
+		{
+			if (this._moreData)
+			{
+				value = this.CurrentSpan[this.CurrentSpanIndex];
+				return true;
+			}
+			else
+			{
+				value = default;
+				return false;
+			}
+		}
+
+		/// <summary>
+		/// Read the next value and advance the reader.
+		/// </summary>
+		/// <param name="value">The next value or default if at the end.</param>
+		/// <returns>False if at the end of the reader.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool TryRead(out T value)
+		{
+			if (this.End)
+			{
+				value = default;
+				return false;
+			}
+
+			value = this.CurrentSpan[this.CurrentSpanIndex];
+			this.CurrentSpanIndex++;
+			this.Consumed++;
+
+			if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
+			{
+				if (this._usingSequence)
+				{
+					this.GetNextSpan();
+				}
+				else
+				{
+					this._moreData = false;
+				}
+			}
+
+			return true;
+		}
+
+		/// <summary>
+		/// Move the reader back the specified number of items.
+		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Rewind(long count)
+		{
+			if (count < 0)
+			{
+				throw new ArgumentOutOfRangeException(nameof(count));
+			}
+
+			this.Consumed -= count;
+
+			if (this.CurrentSpanIndex >= count)
+			{
+				this.CurrentSpanIndex -= (int)count;
+				this._moreData = true;
+			}
+			else if (this._usingSequence)
+			{
+				// Current segment doesn't have enough data, scan backward through segments
+				this.RetreatToPreviousSpan(this.Consumed);
+			}
+			else
+			{
+				throw new ArgumentOutOfRangeException("Rewind went past the start of the memory.");
+			}
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private void RetreatToPreviousSpan(long consumed)
+		{
+			Debug.Assert(this._usingSequence, "usingSequence");
+			this.ResetReader();
+			this.Advance(consumed);
+		}
+
+		private void ResetReader()
+		{
+			Debug.Assert(this._usingSequence, "usingSequence");
+			this.CurrentSpanIndex = 0;
+			this.Consumed = 0;
+			this._currentPosition = this.Sequence.Start;
+			this._nextPosition = this._currentPosition;
+
+			if (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+			{
+				this._moreData = true;
+
+				if (memory.Length == 0)
+				{
+					this.CurrentSpan = default;
+
+					// No data in the first span, move to one with data
+					this.GetNextSpan();
+				}
+				else
+				{
+					this.CurrentSpan = memory.Span;
+				}
+			}
+			else
+			{
+				// No data in any spans and at end of sequence
+				this._moreData = false;
+				this.CurrentSpan = default;
+			}
+		}
+
+		/// <summary>
+		/// Get the next segment with available data, if any.
+		/// </summary>
+		private void GetNextSpan()
+		{
+			Debug.Assert(this._usingSequence, "usingSequence");
+			if (!this.Sequence.IsSingleSegment)
+			{
+				SequencePosition previousNextPosition = this._nextPosition;
+				while (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
+				{
+					this._currentPosition = previousNextPosition;
+					if (memory.Length > 0)
+					{
+						this.CurrentSpan = memory.Span;
+						this.CurrentSpanIndex = 0;
+						return;
+					}
+					else
+					{
+						this.CurrentSpan = default;
+						this.CurrentSpanIndex = 0;
+						previousNextPosition = this._nextPosition;
+					}
+				}
+			}
+
+			this._moreData = false;
+		}
+
+		/// <summary>
+		/// Move the reader ahead the specified number of items.
+		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Advance(long count)
+		{
+			const long TooBigOrNegative = unchecked((long)0xFFFFFFFF80000000);
+			if ((count & TooBigOrNegative) == 0 && this.CurrentSpan.Length - this.CurrentSpanIndex > (int)count)
+			{
+				this.CurrentSpanIndex += (int)count;
+				this.Consumed += count;
+			}
+			else if (this._usingSequence)
+			{
+				// Can't satisfy from the current span
+				this.AdvanceToNextSpan(count);
+			}
+			else if (this.CurrentSpan.Length - this.CurrentSpanIndex == (int)count)
+			{
+				this.CurrentSpanIndex += (int)count;
+				this.Consumed += count;
+				this._moreData = false;
+			}
+			else
+			{
+				throw new ArgumentOutOfRangeException(nameof(count));
+			}
+		}
+
+		/// <summary>
+		/// Unchecked helper to avoid unnecessary checks where you know count is valid.
+		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		internal void AdvanceCurrentSpan(long count)
+		{
+			Debug.Assert(count >= 0, "count >= 0");
+
+			this.Consumed += count;
+			this.CurrentSpanIndex += (int)count;
+			if (this._usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length)
+			{
+				this.GetNextSpan();
+			}
+		}
+
+		/// <summary>
+		/// Only call this helper if you know that you are advancing in the current span
+		/// with valid count and there is no need to fetch the next one.
+		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		internal void AdvanceWithinSpan(long count)
+		{
+			Debug.Assert(count >= 0, "count >= 0");
+
+			this.Consumed += count;
+			this.CurrentSpanIndex += (int)count;
+
+			Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length, "this.CurrentSpanIndex < this.CurrentSpan.Length");
+		}
+
+		/// <summary>
+		/// Move the reader ahead the specified number of items
+		/// if there are enough elements remaining in the sequence.
+		/// </summary>
+		/// <returns><c>true</c> if there were enough elements to advance; otherwise <c>false</c>.</returns>
+		internal bool TryAdvance(long count)
+		{
+			if (this.Remaining < count)
+			{
+				return false;
+			}
+
+			this.Advance(count);
+			return true;
+		}
+
+		private void AdvanceToNextSpan(long count)
+		{
+			Debug.Assert(this._usingSequence, "usingSequence");
+			if (count < 0)
+			{
+				throw new ArgumentOutOfRangeException(nameof(count));
+			}
+
+			this.Consumed += count;
+			while (this._moreData)
+			{
+				int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex;
+
+				if (remaining > count)
+				{
+					this.CurrentSpanIndex += (int)count;
+					count = 0;
+					break;
+				}
+
+				// As there may not be any further segments we need to
+				// push the current index to the end of the span.
+				this.CurrentSpanIndex += remaining;
+				count -= remaining;
+				Debug.Assert(count >= 0, "count >= 0");
+
+				this.GetNextSpan();
+
+				if (count == 0)
+				{
+					break;
+				}
+			}
+
+			if (count != 0)
+			{
+				// Not enough data left- adjust for where we actually ended and throw
+				this.Consumed -= count;
+				throw new ArgumentOutOfRangeException(nameof(count));
+			}
+		}
+
+		/// <summary>
+		/// Copies data from the current <see cref="Position"/> to the given <paramref name="destination"/> span.
+		/// </summary>
+		/// <param name="destination">Destination to copy to.</param>
+		/// <returns>True if there is enough data to copy to the <paramref name="destination"/>.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool TryCopyTo(Span<T> destination)
+		{
+			ReadOnlySpan<T> firstSpan = this.UnreadSpan;
+			if (firstSpan.Length >= destination.Length)
+			{
+				firstSpan.Slice(0, destination.Length).CopyTo(destination);
+				return true;
+			}
+
+			return this.TryCopyMultisegment(destination);
+		}
+
+		internal bool TryCopyMultisegment(Span<T> destination)
+		{
+			if (this.Remaining < destination.Length)
+			{
+				return false;
+			}
+
+			ReadOnlySpan<T> firstSpan = this.UnreadSpan;
+			Debug.Assert(firstSpan.Length < destination.Length, "firstSpan.Length < destination.Length");
+			firstSpan.CopyTo(destination);
+			int copied = firstSpan.Length;
+
+			SequencePosition next = this._nextPosition;
+			while (this.Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
+			{
+				if (nextSegment.Length > 0)
+				{
+					ReadOnlySpan<T> nextSpan = nextSegment.Span;
+					int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);
+					nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));
+					copied += toCopy;
+					if (copied >= destination.Length)
+					{
+						break;
+					}
+				}
+			}
+
+			return true;
+		}
+	}
+}

From f59ad28f0a5d5fffcc0d198729a4c6d9b2e9a9b3 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 6 May 2020 16:16:18 +0900
Subject: [PATCH 07/82] Cancel BlockReader

---
 src/MsgPack.Abstraction/BlockReader`1.cs | 501 -----------------------
 1 file changed, 501 deletions(-)
 delete mode 100644 src/MsgPack.Abstraction/BlockReader`1.cs

diff --git a/src/MsgPack.Abstraction/BlockReader`1.cs b/src/MsgPack.Abstraction/BlockReader`1.cs
deleted file mode 100644
index be0b27f21..000000000
--- a/src/MsgPack.Abstraction/BlockReader`1.cs
+++ /dev/null
@@ -1,501 +0,0 @@
-// This file is originated from MessagePack C# and .NET Core Libraries
-
-// License term of MessagePack C#:
-
-// Copyright (c) All contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-// License term of .NET Core Libraries:
-
-/* Licensed to the .NET Foundation under one or more agreements.
- * The .NET Foundation licenses this file to you under the MIT license.
- * See the LICENSE file in the project root for more information. */
-
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace System.Buffers
-{
-	internal ref partial struct SequenceReader<T>
-		where T : unmanaged, IEquatable<T>
-	{
-		/// <summary>
-		/// A value indicating whether we're using <see cref="_sequence"/> (as opposed to <see cref="_memory"/>.
-		/// </summary>
-		private readonly bool _usingSequence;
-
-		/// <summary>
-		/// Backing for the entire sequence when we're not using <see cref="_memory"/>.
-		/// </summary>
-		private ReadOnlySequence<T> _sequence;
-
-		/// <summary>
-		/// The position at the start of the <see cref="CurrentSpan"/>.
-		/// </summary>
-		private SequencePosition _currentPosition;
-
-		/// <summary>
-		/// The position at the end of the <see cref="CurrentSpan"/>.
-		/// </summary>
-		private SequencePosition _nextPosition;
-
-		/// <summary>
-		/// Backing for the entire sequence when we're not using <see cref="_sequence"/>.
-		/// </summary>
-		private readonly ReadOnlyMemory<T> _memory;
-
-		/// <summary>
-		/// A value indicating whether there is unread data remaining.
-		/// </summary>
-		private bool _moreData;
-
-		/// <summary>
-		/// The total number of elements in the sequence.
-		/// </summary>
-		private long _length;
-
-		/// <summary>
-		/// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
-		/// over the given <see cref="ReadOnlySequence{T}"/>.
-		/// </summary>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public SequenceReader(in ReadOnlySequence<T> sequence)
-		{
-			this._usingSequence = true;
-			this.CurrentSpanIndex = 0;
-			this.Consumed = 0;
-			this._sequence = sequence;
-			this._memory = default;
-			this._currentPosition = sequence.Start;
-			this._length = -1;
-
-			ReadOnlySpan<T> first = sequence.First.Span;
-			this._nextPosition = sequence.GetPosition(first.Length);
-			this.CurrentSpan = first;
-			this._moreData = first.Length > 0;
-
-			if (!this._moreData && !sequence.IsSingleSegment)
-			{
-				this._moreData = true;
-				this.GetNextSpan();
-			}
-		}
-
-		/// <summary>
-		/// Initializes a new instance of the <see cref="SequenceReader{T}"/> struct
-		/// over the given <see cref="ReadOnlyMemory{T}"/>.
-		/// </summary>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public SequenceReader(ReadOnlyMemory<T> memory)
-		{
-			this._usingSequence = false;
-			this.CurrentSpanIndex = 0;
-			this.Consumed = 0;
-			this._memory = memory;
-			this.CurrentSpan = memory.Span;
-			this._length = memory.Length;
-			this._moreData = memory.Length > 0;
-
-			this._currentPosition = default;
-			this._nextPosition = default;
-			this._sequence = default;
-		}
-
-		/// <summary>
-		/// Gets a value indicating whether there is no more data in the <see cref="Sequence"/>.
-		/// </summary>
-		public bool End => !this._moreData;
-
-		/// <summary>
-		/// Gets the underlying <see cref="ReadOnlySequence{T}"/> for the reader.
-		/// </summary>
-		public ReadOnlySequence<T> Sequence
-		{
-			get
-			{
-				if (this._sequence.IsEmpty && !this._memory.IsEmpty)
-				{
-					// We're in memory mode (instead of sequence mode).
-					// Lazily fill in the sequence data.
-					this._sequence = new ReadOnlySequence<T>(this._memory);
-					this._currentPosition = this._sequence.Start;
-					this._nextPosition = this._sequence.End;
-				}
-
-				return this._sequence;
-			}
-		}
-
-		/// <summary>
-		/// Gets the current position in the <see cref="Sequence"/>.
-		/// </summary>
-		public SequencePosition Position
-			=> this.Sequence.GetPosition(this.CurrentSpanIndex, this._currentPosition);
-
-		/// <summary>
-		/// Gets the current segment in the <see cref="Sequence"/> as a span.
-		/// </summary>
-		public ReadOnlySpan<T> CurrentSpan { get; private set; }
-
-		/// <summary>
-		/// Gets the index in the <see cref="CurrentSpan"/>.
-		/// </summary>
-		public int CurrentSpanIndex { get; private set; }
-
-		/// <summary>
-		/// Gets the unread portion of the <see cref="CurrentSpan"/>.
-		/// </summary>
-		public ReadOnlySpan<T> UnreadSpan
-		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			get => this.CurrentSpan.Slice(this.CurrentSpanIndex);
-		}
-
-		/// <summary>
-		/// Gets the total number of <typeparamref name="T"/>'s processed by the reader.
-		/// </summary>
-		public long Consumed { get; private set; }
-
-		/// <summary>
-		/// Gets remaining <typeparamref name="T"/>'s in the reader's <see cref="Sequence"/>.
-		/// </summary>
-		public long Remaining => this.Length - this.Consumed;
-
-		/// <summary>
-		/// Gets count of <typeparamref name="T"/> in the reader's <see cref="Sequence"/>.
-		/// </summary>
-		public long Length
-		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			get
-			{
-				if (this._length < 0)
-				{
-					// Cache the length
-					this._length = this.Sequence.Length;
-				}
-
-				return this._length;
-			}
-		}
-
-		/// <summary>
-		/// Peeks at the next value without advancing the reader.
-		/// </summary>
-		/// <param name="value">The next value or default if at the end.</param>
-		/// <returns>False if at the end of the reader.</returns>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public bool TryPeek(out T value)
-		{
-			if (this._moreData)
-			{
-				value = this.CurrentSpan[this.CurrentSpanIndex];
-				return true;
-			}
-			else
-			{
-				value = default;
-				return false;
-			}
-		}
-
-		/// <summary>
-		/// Read the next value and advance the reader.
-		/// </summary>
-		/// <param name="value">The next value or default if at the end.</param>
-		/// <returns>False if at the end of the reader.</returns>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public bool TryRead(out T value)
-		{
-			if (this.End)
-			{
-				value = default;
-				return false;
-			}
-
-			value = this.CurrentSpan[this.CurrentSpanIndex];
-			this.CurrentSpanIndex++;
-			this.Consumed++;
-
-			if (this.CurrentSpanIndex >= this.CurrentSpan.Length)
-			{
-				if (this._usingSequence)
-				{
-					this.GetNextSpan();
-				}
-				else
-				{
-					this._moreData = false;
-				}
-			}
-
-			return true;
-		}
-
-		/// <summary>
-		/// Move the reader back the specified number of items.
-		/// </summary>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public void Rewind(long count)
-		{
-			if (count < 0)
-			{
-				throw new ArgumentOutOfRangeException(nameof(count));
-			}
-
-			this.Consumed -= count;
-
-			if (this.CurrentSpanIndex >= count)
-			{
-				this.CurrentSpanIndex -= (int)count;
-				this._moreData = true;
-			}
-			else if (this._usingSequence)
-			{
-				// Current segment doesn't have enough data, scan backward through segments
-				this.RetreatToPreviousSpan(this.Consumed);
-			}
-			else
-			{
-				throw new ArgumentOutOfRangeException("Rewind went past the start of the memory.");
-			}
-		}
-
-		[MethodImpl(MethodImplOptions.NoInlining)]
-		private void RetreatToPreviousSpan(long consumed)
-		{
-			Debug.Assert(this._usingSequence, "usingSequence");
-			this.ResetReader();
-			this.Advance(consumed);
-		}
-
-		private void ResetReader()
-		{
-			Debug.Assert(this._usingSequence, "usingSequence");
-			this.CurrentSpanIndex = 0;
-			this.Consumed = 0;
-			this._currentPosition = this.Sequence.Start;
-			this._nextPosition = this._currentPosition;
-
-			if (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
-			{
-				this._moreData = true;
-
-				if (memory.Length == 0)
-				{
-					this.CurrentSpan = default;
-
-					// No data in the first span, move to one with data
-					this.GetNextSpan();
-				}
-				else
-				{
-					this.CurrentSpan = memory.Span;
-				}
-			}
-			else
-			{
-				// No data in any spans and at end of sequence
-				this._moreData = false;
-				this.CurrentSpan = default;
-			}
-		}
-
-		/// <summary>
-		/// Get the next segment with available data, if any.
-		/// </summary>
-		private void GetNextSpan()
-		{
-			Debug.Assert(this._usingSequence, "usingSequence");
-			if (!this.Sequence.IsSingleSegment)
-			{
-				SequencePosition previousNextPosition = this._nextPosition;
-				while (this.Sequence.TryGet(ref this._nextPosition, out ReadOnlyMemory<T> memory, advance: true))
-				{
-					this._currentPosition = previousNextPosition;
-					if (memory.Length > 0)
-					{
-						this.CurrentSpan = memory.Span;
-						this.CurrentSpanIndex = 0;
-						return;
-					}
-					else
-					{
-						this.CurrentSpan = default;
-						this.CurrentSpanIndex = 0;
-						previousNextPosition = this._nextPosition;
-					}
-				}
-			}
-
-			this._moreData = false;
-		}
-
-		/// <summary>
-		/// Move the reader ahead the specified number of items.
-		/// </summary>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public void Advance(long count)
-		{
-			const long TooBigOrNegative = unchecked((long)0xFFFFFFFF80000000);
-			if ((count & TooBigOrNegative) == 0 && this.CurrentSpan.Length - this.CurrentSpanIndex > (int)count)
-			{
-				this.CurrentSpanIndex += (int)count;
-				this.Consumed += count;
-			}
-			else if (this._usingSequence)
-			{
-				// Can't satisfy from the current span
-				this.AdvanceToNextSpan(count);
-			}
-			else if (this.CurrentSpan.Length - this.CurrentSpanIndex == (int)count)
-			{
-				this.CurrentSpanIndex += (int)count;
-				this.Consumed += count;
-				this._moreData = false;
-			}
-			else
-			{
-				throw new ArgumentOutOfRangeException(nameof(count));
-			}
-		}
-
-		/// <summary>
-		/// Unchecked helper to avoid unnecessary checks where you know count is valid.
-		/// </summary>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		internal void AdvanceCurrentSpan(long count)
-		{
-			Debug.Assert(count >= 0, "count >= 0");
-
-			this.Consumed += count;
-			this.CurrentSpanIndex += (int)count;
-			if (this._usingSequence && this.CurrentSpanIndex >= this.CurrentSpan.Length)
-			{
-				this.GetNextSpan();
-			}
-		}
-
-		/// <summary>
-		/// Only call this helper if you know that you are advancing in the current span
-		/// with valid count and there is no need to fetch the next one.
-		/// </summary>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		internal void AdvanceWithinSpan(long count)
-		{
-			Debug.Assert(count >= 0, "count >= 0");
-
-			this.Consumed += count;
-			this.CurrentSpanIndex += (int)count;
-
-			Debug.Assert(this.CurrentSpanIndex < this.CurrentSpan.Length, "this.CurrentSpanIndex < this.CurrentSpan.Length");
-		}
-
-		/// <summary>
-		/// Move the reader ahead the specified number of items
-		/// if there are enough elements remaining in the sequence.
-		/// </summary>
-		/// <returns><c>true</c> if there were enough elements to advance; otherwise <c>false</c>.</returns>
-		internal bool TryAdvance(long count)
-		{
-			if (this.Remaining < count)
-			{
-				return false;
-			}
-
-			this.Advance(count);
-			return true;
-		}
-
-		private void AdvanceToNextSpan(long count)
-		{
-			Debug.Assert(this._usingSequence, "usingSequence");
-			if (count < 0)
-			{
-				throw new ArgumentOutOfRangeException(nameof(count));
-			}
-
-			this.Consumed += count;
-			while (this._moreData)
-			{
-				int remaining = this.CurrentSpan.Length - this.CurrentSpanIndex;
-
-				if (remaining > count)
-				{
-					this.CurrentSpanIndex += (int)count;
-					count = 0;
-					break;
-				}
-
-				// As there may not be any further segments we need to
-				// push the current index to the end of the span.
-				this.CurrentSpanIndex += remaining;
-				count -= remaining;
-				Debug.Assert(count >= 0, "count >= 0");
-
-				this.GetNextSpan();
-
-				if (count == 0)
-				{
-					break;
-				}
-			}
-
-			if (count != 0)
-			{
-				// Not enough data left- adjust for where we actually ended and throw
-				this.Consumed -= count;
-				throw new ArgumentOutOfRangeException(nameof(count));
-			}
-		}
-
-		/// <summary>
-		/// Copies data from the current <see cref="Position"/> to the given <paramref name="destination"/> span.
-		/// </summary>
-		/// <param name="destination">Destination to copy to.</param>
-		/// <returns>True if there is enough data to copy to the <paramref name="destination"/>.</returns>
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		public bool TryCopyTo(Span<T> destination)
-		{
-			ReadOnlySpan<T> firstSpan = this.UnreadSpan;
-			if (firstSpan.Length >= destination.Length)
-			{
-				firstSpan.Slice(0, destination.Length).CopyTo(destination);
-				return true;
-			}
-
-			return this.TryCopyMultisegment(destination);
-		}
-
-		internal bool TryCopyMultisegment(Span<T> destination)
-		{
-			if (this.Remaining < destination.Length)
-			{
-				return false;
-			}
-
-			ReadOnlySpan<T> firstSpan = this.UnreadSpan;
-			Debug.Assert(firstSpan.Length < destination.Length, "firstSpan.Length < destination.Length");
-			firstSpan.CopyTo(destination);
-			int copied = firstSpan.Length;
-
-			SequencePosition next = this._nextPosition;
-			while (this.Sequence.TryGet(ref next, out ReadOnlyMemory<T> nextSegment, true))
-			{
-				if (nextSegment.Length > 0)
-				{
-					ReadOnlySpan<T> nextSpan = nextSegment.Span;
-					int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);
-					nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));
-					copied += toCopy;
-					if (copied >= destination.Length)
-					{
-						break;
-					}
-				}
-			}
-
-			return true;
-		}
-	}
-}

From 73c59ad49dddf0d970533eefcb7878e95c4ae833 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 6 May 2020 16:18:00 +0900
Subject: [PATCH 08/82] Port .NET 5 EncodingExtensions

---
 LICENSE.DotNetFoundation.txt                  |  23 +
 .../System.Text/EncodingExtensions.cs         | 633 ++++++++++++++++++
 2 files changed, 656 insertions(+)
 create mode 100644 LICENSE.DotNetFoundation.txt
 create mode 100644 src/MsgPack.Core/System.Text/EncodingExtensions.cs

diff --git a/LICENSE.DotNetFoundation.txt b/LICENSE.DotNetFoundation.txt
new file mode 100644
index 000000000..a616ed188
--- /dev/null
+++ b/LICENSE.DotNetFoundation.txt
@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) .NET Foundation and Contributors
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/src/MsgPack.Core/System.Text/EncodingExtensions.cs b/src/MsgPack.Core/System.Text/EncodingExtensions.cs
new file mode 100644
index 000000000..b204df465
--- /dev/null
+++ b/src/MsgPack.Core/System.Text/EncodingExtensions.cs
@@ -0,0 +1,633 @@
+// This file is licensed under MIT license.
+// See the LICENSE.DotNetFoundation in the project root for more information.
+
+// This file is ported from .NET 5 https://github.com/dotnet/runtime/blob/a4c050ebf45a9745e2941863a8d7ae9c70ee88b2/src/libraries/System.Memory/src/System/Text/EncodingExtensions.cs#L1
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace System.Text
+{
+	public static class EncodingExtensions
+	{
+		/// <summary>
+		/// The maximum number of input elements after which we'll begin to chunk the input.
+		/// </summary>
+		/// <remarks>
+		/// The reason for this chunking is that the existing Encoding / Encoder / Decoder APIs
+		/// like GetByteCount / GetCharCount will throw if an integer overflow occurs. Since
+		/// we may be working with large inputs in these extension methods, we don't want to
+		/// risk running into this issue. While it's technically possible even for 1 million
+		/// input elements to result in an overflow condition, such a scenario is unrealistic,
+		/// so we won't worry about it.
+		/// </remarks>
+		private const int MaxInputElementsPerIteration = 1 * 1024 * 1024;
+
+		/// <summary>
+		/// Encodes the specified <see cref="ReadOnlySpan{Char}"/> to <see langword="byte"/>s using the specified <see cref="Encoding"/>
+		/// and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="chars"/> should be encoded.</param>
+		/// <param name="chars">The <see cref="ReadOnlySequence{Char}"/> to encode to <see langword="byte"/>s.</param>
+		/// <param name="writer">The buffer to which the encoded bytes will be written.</param>
+		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static long GetBytes(this Encoding encoding, ReadOnlySpan<char> chars, IBufferWriter<byte> writer)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (writer is null)
+			{
+				throw new ArgumentNullException(nameof(writer));
+			}
+
+			if (chars.Length <= MaxInputElementsPerIteration)
+			{
+				// The input span is small enough where we can one-shot this.
+
+				int byteCount = encoding.GetByteCount(chars);
+				Span<byte> scratchBuffer = writer.GetSpan(byteCount);
+
+				int actualBytesWritten = encoding.GetBytes(chars, scratchBuffer);
+
+				writer.Advance(actualBytesWritten);
+				return actualBytesWritten;
+			}
+			else
+			{
+				// Allocate a stateful Encoder instance and chunk this.
+
+				Convert(encoding.GetEncoder(), chars, writer, flush: true, out long totalBytesWritten, out bool completed);
+				return totalBytesWritten;
+			}
+		}
+
+		/// <summary>
+		/// Decodes the specified <see cref="ReadOnlySequence{Char}"/> to <see langword="byte"/>s using the specified <see cref="Encoding"/>
+		/// and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="chars"/> should be encoded.</param>
+		/// <param name="chars">The <see cref="ReadOnlySequence{Char}"/> whose contents should be encoded.</param>
+		/// <param name="writer">The buffer to which the encoded bytes will be written.</param>
+		/// <returns>The number of bytes written to <paramref name="writer"/>.</returns>
+		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static long GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars, IBufferWriter<byte> writer)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (writer is null)
+			{
+				throw new ArgumentNullException(nameof(writer));
+			}
+
+			// Delegate to the Span-based method if possible.
+			// If that doesn't work, allocate the Encoder instance and run a loop.
+
+			if (chars.IsSingleSegment)
+			{
+				return GetBytes(encoding, chars.FirstSpan, writer);
+			}
+			else
+			{
+				Convert(encoding.GetEncoder(), chars, writer, flush: true, out long bytesWritten, out bool completed);
+				return bytesWritten;
+			}
+		}
+
+		/// <summary>
+		/// Encodes the specified <see cref="ReadOnlySequence{Char}"/> to <see langword="byte"/>s using the specified <see cref="Encoding"/>
+		/// and outputs the result to <paramref name="bytes"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="chars"/> should be encoded.</param>
+		/// <param name="chars">The <see cref="ReadOnlySequence{Char}"/> to encode to <see langword="byte"/>s.</param>
+		/// <param name="bytes">The destination buffer to which the encoded bytes will be written.</param>
+		/// <returns>The number of bytes written to <paramref name="bytes"/>.</returns>
+		/// <exception cref="ArgumentException">Thrown if <paramref name="bytes"/> is not large enough to contain the encoded form of <paramref name="chars"/>.</exception>
+		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static int GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars, Span<byte> bytes)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (chars.IsSingleSegment)
+			{
+				// If the incoming sequence is single-segment, one-shot this.
+
+				return encoding.GetBytes(chars.FirstSpan, bytes);
+			}
+			else
+			{
+				// If the incoming sequence is multi-segment, create a stateful Encoder
+				// and use it as the workhorse. On the final iteration we'll pass flush=true.
+
+				ReadOnlySequence<char> remainingChars = chars;
+				int originalBytesLength = bytes.Length;
+				Encoder encoder = encoding.GetEncoder();
+				bool isFinalSegment;
+
+				do
+				{
+					remainingChars.GetFirstSpan(out ReadOnlySpan<char> firstSpan, out SequencePosition next);
+					isFinalSegment = remainingChars.IsSingleSegment;
+
+					int bytesWrittenJustNow = encoder.GetBytes(firstSpan, bytes, flush: isFinalSegment);
+					bytes = bytes.Slice(bytesWrittenJustNow);
+					remainingChars = remainingChars.Slice(next);
+				} while (!isFinalSegment);
+
+				return originalBytesLength - bytes.Length; // total number of bytes we wrote
+			}
+		}
+
+		/// <summary>
+		/// Encodes the specified <see cref="ReadOnlySequence{Char}"/> into a <see cref="byte"/> array using the specified <see cref="Encoding"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="chars"/> should be encoded.</param>
+		/// <param name="chars">The <see cref="ReadOnlySequence{Char}"/> to encode to <see langword="byte"/>s.</param>
+		/// <returns>A <see cref="byte"/> array which represents the encoded contents of <paramref name="chars"/>.</returns>
+		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static byte[] GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (chars.IsSingleSegment)
+			{
+				// If the incoming sequence is single-segment, one-shot this.
+
+				ReadOnlySpan<char> span = chars.FirstSpan;
+
+				byte[] retVal = new byte[encoding.GetByteCount(span)];
+				encoding.GetBytes(span, retVal);
+				return retVal;
+			}
+			else
+			{
+				// If the incoming sequence is multi-segment, create a stateful Encoder
+				// and use it as the workhorse. On the final iteration we'll pass flush=true.
+
+				Encoder encoder = encoding.GetEncoder();
+
+				// Maintain a list of all the segments we'll need to concat together.
+				// These will be released back to the pool at the end of the method.
+
+				List<(byte[], int)> listOfSegments = new List<(byte[], int)>();
+				int totalByteCount = 0;
+
+				ReadOnlySequence<char> remainingChars = chars;
+				bool isFinalSegment;
+
+				do
+				{
+					remainingChars.GetFirstSpan(out ReadOnlySpan<char> firstSpan, out SequencePosition next);
+					isFinalSegment = remainingChars.IsSingleSegment;
+
+					int byteCountThisIteration = encoder.GetByteCount(firstSpan, flush: isFinalSegment);
+					byte[] rentedArray = ArrayPool<byte>.Shared.Rent(byteCountThisIteration);
+					int actualBytesWrittenThisIteration = encoder.GetBytes(firstSpan, rentedArray, flush: isFinalSegment); // could throw ArgumentException if overflow would occur
+					listOfSegments.Add((rentedArray, actualBytesWrittenThisIteration));
+
+					totalByteCount += actualBytesWrittenThisIteration;
+					if (totalByteCount < 0)
+					{
+						// If we overflowed, call the array ctor, passing int.MaxValue.
+						// This will end up throwing the expected OutOfMemoryException
+						// since arrays are limited to under int.MaxValue elements in length.
+
+						totalByteCount = int.MaxValue;
+						break;
+					}
+
+					remainingChars = remainingChars.Slice(next);
+				} while (!isFinalSegment);
+
+				// Now build up the byte[] to return, then release all of our scratch buffers
+				// back to the shared pool.
+
+				byte[] retVal = new byte[totalByteCount];
+				Span<byte> remainingBytes = retVal;
+
+				foreach ((byte[] array, int length) in listOfSegments)
+				{
+					array.AsSpan(0, length).CopyTo(remainingBytes);
+					ArrayPool<byte>.Shared.Return(array);
+					remainingBytes = remainingBytes.Slice(length);
+				}
+
+				Debug.Assert(remainingBytes.IsEmpty, "Over-allocated the byte[] instance?");
+
+				return retVal;
+			}
+		}
+
+		/// <summary>
+		/// Decodes the specified <see cref="ReadOnlySpan{Byte}"/> to <see langword="char"/>s using the specified <see cref="Encoding"/>
+		/// and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="bytes"/> should be decoded.</param>
+		/// <param name="bytes">The <see cref="ReadOnlySpan{Byte}"/> whose bytes should be decoded.</param>
+		/// <param name="writer">The buffer to which the decoded chars will be written.</param>
+		/// <returns>The number of chars written to <paramref name="writer"/>.</returns>
+		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be decoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static long GetChars(this Encoding encoding, ReadOnlySpan<byte> bytes, IBufferWriter<char> writer)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (writer is null)
+			{
+				throw new ArgumentNullException(nameof(writer));
+			}
+
+			if (bytes.Length <= MaxInputElementsPerIteration)
+			{
+				// The input span is small enough where we can one-shot this.
+
+				int charCount = encoding.GetCharCount(bytes);
+				Span<char> scratchBuffer = writer.GetSpan(charCount);
+
+				int actualCharsWritten = encoding.GetChars(bytes, scratchBuffer);
+
+				writer.Advance(actualCharsWritten);
+				return actualCharsWritten;
+			}
+			else
+			{
+				// Allocate a stateful Decoder instance and chunk this.
+
+				Convert(encoding.GetDecoder(), bytes, writer, flush: true, out long totalCharsWritten, out bool completed);
+				return totalCharsWritten;
+			}
+		}
+
+		/// <summary>
+		/// Decodes the specified <see cref="ReadOnlySequence{Byte}"/> to <see langword="char"/>s using the specified <see cref="Encoding"/>
+		/// and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="bytes"/> should be decoded.</param>
+		/// <param name="bytes">The <see cref="ReadOnlySequence{Byte}"/> whose bytes should be decoded.</param>
+		/// <param name="writer">The buffer to which the decoded chars will be written.</param>
+		/// <returns>The number of chars written to <paramref name="writer"/>.</returns>
+		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be decoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static long GetChars(this Encoding encoding, in ReadOnlySequence<byte> bytes, IBufferWriter<char> writer)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (writer is null)
+			{
+				throw new ArgumentNullException(nameof(writer));
+			}
+
+			// Delegate to the Span-based method if possible.
+			// If that doesn't work, allocate the Encoder instance and run a loop.
+
+			if (bytes.IsSingleSegment)
+			{
+				return GetChars(encoding, bytes.FirstSpan, writer);
+			}
+			else
+			{
+				Convert(encoding.GetDecoder(), bytes, writer, flush: true, out long charsWritten, out bool completed);
+				return charsWritten;
+			}
+		}
+
+		/// <summary>
+		/// Decodes the specified <see cref="ReadOnlySequence{Byte}"/> to <see langword="char"/>s using the specified <see cref="Encoding"/>
+		/// and outputs the result to <paramref name="chars"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="bytes"/> is encoded.</param>
+		/// <param name="bytes">The <see cref="ReadOnlySequence{Byte}"/> to decode to characters.</param>
+		/// <param name="chars">The destination buffer to which the decoded characters will be written.</param>
+		/// <returns>The number of chars written to <paramref name="chars"/>.</returns>
+		/// <exception cref="ArgumentException">Thrown if <paramref name="chars"/> is not large enough to contain the encoded form of <paramref name="bytes"/>.</exception>
+		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be decoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static int GetChars(this Encoding encoding, in ReadOnlySequence<byte> bytes, Span<char> chars)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (bytes.IsSingleSegment)
+			{
+				// If the incoming sequence is single-segment, one-shot this.
+
+				return encoding.GetChars(bytes.FirstSpan, chars);
+			}
+			else
+			{
+				// If the incoming sequence is multi-segment, create a stateful Decoder
+				// and use it as the workhorse. On the final iteration we'll pass flush=true.
+
+				ReadOnlySequence<byte> remainingBytes = bytes;
+				int originalCharsLength = chars.Length;
+				Decoder decoder = encoding.GetDecoder();
+				bool isFinalSegment;
+
+				do
+				{
+					remainingBytes.GetFirstSpan(out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+					isFinalSegment = remainingBytes.IsSingleSegment;
+
+					int charsWrittenJustNow = decoder.GetChars(firstSpan, chars, flush: isFinalSegment);
+					chars = chars.Slice(charsWrittenJustNow);
+					remainingBytes = remainingBytes.Slice(next);
+				} while (!isFinalSegment);
+
+				return originalCharsLength - chars.Length; // total number of chars we wrote
+			}
+		}
+
+		/// <summary>
+		/// Decodes the specified <see cref="ReadOnlySequence{Byte}"/> into a <see cref="string"/> using the specified <see cref="Encoding"/>.
+		/// </summary>
+		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="bytes"/> is encoded.</param>
+		/// <param name="bytes">The <see cref="ReadOnlySequence{Byte}"/> to decode into characters.</param>
+		/// <returns>A <see cref="string"/> which represents the decoded contents of <paramref name="bytes"/>.</returns>
+		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be decoded and <paramref name="encoding"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static string GetString(this Encoding encoding, in ReadOnlySequence<byte> bytes)
+		{
+			if (encoding is null)
+			{
+				throw new ArgumentNullException(nameof(encoding));
+			}
+
+			if (bytes.IsSingleSegment)
+			{
+				// If the incoming sequence is single-segment, one-shot this.
+
+				return encoding.GetString(bytes.FirstSpan);
+			}
+			else
+			{
+				// If the incoming sequence is multi-segment, create a stateful Decoder
+				// and use it as the workhorse. On the final iteration we'll pass flush=true.
+
+				Decoder decoder = encoding.GetDecoder();
+
+				// Maintain a list of all the segments we'll need to concat together.
+				// These will be released back to the pool at the end of the method.
+
+				List<(char[], int)> listOfSegments = new List<(char[], int)>();
+				int totalCharCount = 0;
+
+				ReadOnlySequence<byte> remainingBytes = bytes;
+				bool isFinalSegment;
+
+				do
+				{
+					remainingBytes.GetFirstSpan(out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+					isFinalSegment = remainingBytes.IsSingleSegment;
+
+					int charCountThisIteration = decoder.GetCharCount(firstSpan, flush: isFinalSegment); // could throw ArgumentException if overflow would occur
+					char[] rentedArray = ArrayPool<char>.Shared.Rent(charCountThisIteration);
+					int actualCharsWrittenThisIteration = decoder.GetChars(firstSpan, rentedArray, flush: isFinalSegment);
+					listOfSegments.Add((rentedArray, actualCharsWrittenThisIteration));
+
+					totalCharCount += actualCharsWrittenThisIteration;
+					if (totalCharCount < 0)
+					{
+						// If we overflowed, call string.Create, passing int.MaxValue.
+						// This will end up throwing the expected OutOfMemoryException
+						// since strings are limited to under int.MaxValue elements in length.
+
+						totalCharCount = int.MaxValue;
+						break;
+					}
+
+					remainingBytes = remainingBytes.Slice(next);
+				} while (!isFinalSegment);
+
+				// Now build up the string to return, then release all of our scratch buffers
+				// back to the shared pool.
+
+				return string.Create(totalCharCount, listOfSegments, (span, listOfSegments) =>
+				{
+					foreach ((char[] array, int length) in listOfSegments)
+					{
+						array.AsSpan(0, length).CopyTo(span);
+						ArrayPool<char>.Shared.Return(array);
+						span = span.Slice(length);
+					}
+
+					Debug.Assert(span.IsEmpty, "Over-allocated the string instance?");
+				});
+			}
+		}
+
+		/// <summary>
+		/// Converts a <see cref="ReadOnlySpan{Char}"/> to bytes using <paramref name="encoder"/> and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="encoder">The <see cref="Encoder"/> instance which can convert <see langword="char"/>s to <see langword="byte"/>s.</param>
+		/// <param name="chars">A sequence of characters to encode.</param>
+		/// <param name="writer">The buffer to which the encoded bytes will be written.</param>
+		/// <param name="flush"><see langword="true"/> to indicate no further data is to be converted; otherwise <see langword="false"/>.</param>
+		/// <param name="bytesUsed">When this method returns, contains the count of <see langword="byte"/>s which were written to <paramref name="writer"/>.</param>
+		/// <param name="completed">
+		/// When this method returns, contains <see langword="true"/> if <paramref name="encoder"/> contains no partial internal state; otherwise, <see langword="false"/>.
+		/// If <paramref name="flush"/> is <see langword="true"/>, this will always be set to <see langword="true"/> when the method returns.
+		/// </param>
+		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoder"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static void Convert(this Encoder encoder, ReadOnlySpan<char> chars, IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed)
+		{
+			if (encoder is null)
+			{
+				throw new ArgumentNullException(nameof(encoder));
+			}
+
+			if (writer is null)
+			{
+				throw new ArgumentNullException(nameof(writer));
+			}
+
+			// We need to perform at least one iteration of the loop since the encoder could have internal state.
+
+			long totalBytesWritten = 0;
+
+			do
+			{
+				// If our remaining input is very large, instead truncate it and tell the encoder
+				// that there'll be more data after this call. This truncation is only for the
+				// purposes of getting the required byte count. Since the writer may give us a span
+				// larger than what we asked for, we'll pass the entirety of the remaining data
+				// to the transcoding routine, since it may be able to make progress beyond what
+				// was initially computed for the truncated input data.
+
+				int byteCountForThisSlice = (chars.Length <= MaxInputElementsPerIteration)
+				  ? encoder.GetByteCount(chars, flush)
+				  : encoder.GetByteCount(chars.Slice(0, MaxInputElementsPerIteration), flush: false /* this isn't the end of the data */);
+
+				Span<byte> scratchBuffer = writer.GetSpan(byteCountForThisSlice);
+
+				encoder.Convert(chars, scratchBuffer, flush, out int charsUsedJustNow, out int bytesWrittenJustNow, out completed);
+
+				chars = chars.Slice(charsUsedJustNow);
+				writer.Advance(bytesWrittenJustNow);
+				totalBytesWritten += bytesWrittenJustNow;
+			} while (!chars.IsEmpty);
+
+			bytesUsed = totalBytesWritten;
+		}
+
+		/// <summary>
+		/// Converts a <see cref="ReadOnlySequence{Char}"/> to encoded bytes and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="encoder">The <see cref="Encoder"/> instance which can convert <see langword="char"/>s to <see langword="byte"/>s.</param>
+		/// <param name="chars">A sequence of characters to encode.</param>
+		/// <param name="writer">The buffer to which the encoded bytes will be written.</param>
+		/// <param name="flush"><see langword="true"/> to indicate no further data is to be converted; otherwise <see langword="false"/>.</param>
+		/// <param name="bytesUsed">When this method returns, contains the count of <see langword="byte"/>s which were written to <paramref name="writer"/>.</param>
+		/// <param name="completed">When this method returns, contains <see langword="true"/> if all input up until <paramref name="bytesUsed"/> was
+		/// converted; otherwise, <see langword="false"/>. If <paramref name="flush"/> is <see langword="true"/>, this will always be set to
+		/// <see langword="true"/> when the method returns.</param>
+		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoder"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static void Convert(this Encoder encoder, in ReadOnlySequence<char> chars, IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed)
+		{
+			// Parameter null checks will be performed by the workhorse routine.
+
+			ReadOnlySequence<char> remainingChars = chars;
+			long totalBytesWritten = 0;
+			bool isFinalSegment;
+
+			do
+			{
+				// Process each segment individually. We need to run at least one iteration of the loop in case
+				// the Encoder has internal state.
+
+				remainingChars..GetFirstSpan(out ReadOnlySpan<char> firstSpan, out SequencePosition next);
+				isFinalSegment = remainingChars.IsSingleSegment;
+
+				Convert(encoder, firstSpan, writer, flush && isFinalSegment, out long bytesWrittenThisIteration, out completed);
+
+				totalBytesWritten += bytesWrittenThisIteration;
+				remainingChars = remainingChars.Slice(next);
+			} while (!isFinalSegment);
+
+			bytesUsed = totalBytesWritten;
+		}
+
+		/// <summary>
+		/// Converts a <see cref="ReadOnlySpan{Byte}"/> to chars using <paramref name="decoder"/> and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="decoder">The <see cref="Decoder"/> instance which can convert <see langword="byte"/>s to <see langword="char"/>s.</param>
+		/// <param name="bytes">A sequence of bytes to decode.</param>
+		/// <param name="writer">The buffer to which the decoded chars will be written.</param>
+		/// <param name="flush"><see langword="true"/> to indicate no further data is to be converted; otherwise <see langword="false"/>.</param>
+		/// <param name="charsUsed">When this method returns, contains the count of <see langword="char"/>s which were written to <paramref name="writer"/>.</param>
+		/// <param name="completed">
+		/// When this method returns, contains <see langword="true"/> if <paramref name="decoder"/> contains no partial internal state; otherwise, <see langword="false"/>.
+		/// If <paramref name="flush"/> is <see langword="true"/>, this will always be set to <see langword="true"/> when the method returns.
+		/// </param>
+		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be encoded and <paramref name="decoder"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static void Convert(this Decoder decoder, ReadOnlySpan<byte> bytes, IBufferWriter<char> writer, bool flush, out long charsUsed, out bool completed)
+		{
+			if (decoder is null)
+			{
+				throw new ArgumentNullException(nameof(decoder));
+			}
+
+			if (writer is null)
+			{
+				throw new ArgumentNullException(nameof(writer));
+			}
+
+			// We need to perform at least one iteration of the loop since the decoder could have internal state.
+
+			long totalCharsWritten = 0;
+
+			do
+			{
+				// If our remaining input is very large, instead truncate it and tell the decoder
+				// that there'll be more data after this call. This truncation is only for the
+				// purposes of getting the required char count. Since the writer may give us a span
+				// larger than what we asked for, we'll pass the entirety of the remaining data
+				// to the transcoding routine, since it may be able to make progress beyond what
+				// was initially computed for the truncated input data.
+
+				int charCountForThisSlice = (bytes.Length <= MaxInputElementsPerIteration)
+					? decoder.GetCharCount(bytes, flush)
+					: decoder.GetCharCount(bytes.Slice(0, MaxInputElementsPerIteration), flush: false /* this isn't the end of the data */);
+
+				Span<char> scratchBuffer = writer.GetSpan(charCountForThisSlice);
+
+				decoder.Convert(bytes, scratchBuffer, flush, out int bytesUsedJustNow, out int charsWrittenJustNow, out completed);
+
+				bytes = bytes.Slice(bytesUsedJustNow);
+				writer.Advance(charsWrittenJustNow);
+				totalCharsWritten += charsWrittenJustNow;
+			} while (!bytes.IsEmpty);
+
+			charsUsed = totalCharsWritten;
+		}
+
+		/// <summary>
+		/// Converts a <see cref="ReadOnlySequence{Byte}"/> to UTF-16 encoded characters and writes the result to <paramref name="writer"/>.
+		/// </summary>
+		/// <param name="decoder">The <see cref="Decoder"/> instance which can convert <see langword="byte"/>s to <see langword="char"/>s.</param>
+		/// <param name="bytes">A sequence of bytes to decode.</param>
+		/// <param name="writer">The buffer to which the decoded characters will be written.</param>
+		/// <param name="flush"><see langword="true"/> to indicate no further data is to be converted; otherwise <see langword="false"/>.</param>
+		/// <param name="charsUsed">When this method returns, contains the count of <see langword="char"/>s which were written to <paramref name="writer"/>.</param>
+		/// <param name="completed">
+		/// When this method returns, contains <see langword="true"/> if <paramref name="decoder"/> contains no partial internal state; otherwise, <see langword="false"/>.
+		/// If <paramref name="flush"/> is <see langword="true"/>, this will always be set to <see langword="true"/> when the method returns.
+		/// </param>
+		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be decoded and <paramref name="decoder"/> is configured
+		/// to throw an exception when such data is seen.</exception>
+		public static void Convert(this Decoder decoder, in ReadOnlySequence<byte> bytes, IBufferWriter<char> writer, bool flush, out long charsUsed, out bool completed)
+		{
+			// Parameter null checks will be performed by the workhorse routine.
+
+			ReadOnlySequence<byte> remainingBytes = bytes;
+			long totalCharsWritten = 0;
+			bool isFinalSegment;
+
+			do
+			{
+				// Process each segment individually. We need to run at least one iteration of the loop in case
+				// the Decoder has internal state.
+
+				remainingBytes.GetFirstSpan(out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+				isFinalSegment = remainingBytes.IsSingleSegment;
+
+				Convert(decoder, firstSpan, writer, flush && isFinalSegment, out long charsWrittenThisIteration, out completed);
+
+				totalCharsWritten += charsWrittenThisIteration;
+				remainingBytes = remainingBytes.Slice(next);
+			} while (!isFinalSegment);
+
+			charsUsed = totalCharsWritten;
+		}
+	}
+}

From 8536ac64435191583f5a6b00c3873db376f3239d Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 6 May 2020 16:52:54 +0900
Subject: [PATCH 09/82] Port .NET 5 EncodingExtensions to .NET Core 3.1

* Add psuedo GetFirstSpan() internal method.
* Fix code format to compliant project's rule.
---
 .../System.Text/EncodingExtensions.cs         | 64 +++++++++++++++----
 1 file changed, 50 insertions(+), 14 deletions(-)

diff --git a/src/MsgPack.Core/System.Text/EncodingExtensions.cs b/src/MsgPack.Core/System.Text/EncodingExtensions.cs
index b204df465..9cc34cbd3 100644
--- a/src/MsgPack.Core/System.Text/EncodingExtensions.cs
+++ b/src/MsgPack.Core/System.Text/EncodingExtensions.cs
@@ -1,3 +1,4 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under MIT license.
 // See the LICENSE.DotNetFoundation in the project root for more information.
 
@@ -10,10 +11,13 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using MsgPack.Internal;
 
 namespace System.Text
 {
-	public static class EncodingExtensions
+	internal static class EncodingExtensions
 	{
 		/// <summary>
 		/// The maximum number of input elements after which we'll begin to chunk the input.
@@ -142,7 +146,7 @@ public static int GetBytes(this Encoding encoding, in ReadOnlySequence<char> cha
 
 				do
 				{
-					remainingChars.GetFirstSpan(out ReadOnlySpan<char> firstSpan, out SequencePosition next);
+					GetFirstSpan(remainingChars, out ReadOnlySpan<char> firstSpan, out SequencePosition next);
 					isFinalSegment = remainingChars.IsSingleSegment;
 
 					int bytesWrittenJustNow = encoder.GetBytes(firstSpan, bytes, flush: isFinalSegment);
@@ -155,11 +159,11 @@ public static int GetBytes(this Encoding encoding, in ReadOnlySequence<char> cha
 		}
 
 		/// <summary>
-		/// Encodes the specified <see cref="ReadOnlySequence{Char}"/> into a <see cref="byte"/> array using the specified <see cref="Encoding"/>.
+		/// Encodes the specified <see cref="ReadOnlySequence{Char}"/> into a <see cref="Byte"/> array using the specified <see cref="Encoding"/>.
 		/// </summary>
 		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="chars"/> should be encoded.</param>
 		/// <param name="chars">The <see cref="ReadOnlySequence{Char}"/> to encode to <see langword="byte"/>s.</param>
-		/// <returns>A <see cref="byte"/> array which represents the encoded contents of <paramref name="chars"/>.</returns>
+		/// <returns>A <see cref="Byte"/> array which represents the encoded contents of <paramref name="chars"/>.</returns>
 		/// <exception cref="EncoderFallbackException">Thrown if <paramref name="chars"/> contains data that cannot be encoded and <paramref name="encoding"/> is configured
 		/// to throw an exception when such data is seen.</exception>
 		public static byte[] GetBytes(this Encoding encoding, in ReadOnlySequence<char> chars)
@@ -197,7 +201,7 @@ public static byte[] GetBytes(this Encoding encoding, in ReadOnlySequence<char>
 
 				do
 				{
-					remainingChars.GetFirstSpan(out ReadOnlySpan<char> firstSpan, out SequencePosition next);
+					GetFirstSpan(remainingChars, out ReadOnlySpan<char> firstSpan, out SequencePosition next);
 					isFinalSegment = remainingChars.IsSingleSegment;
 
 					int byteCountThisIteration = encoder.GetByteCount(firstSpan, flush: isFinalSegment);
@@ -212,7 +216,7 @@ public static byte[] GetBytes(this Encoding encoding, in ReadOnlySequence<char>
 						// This will end up throwing the expected OutOfMemoryException
 						// since arrays are limited to under int.MaxValue elements in length.
 
-						totalByteCount = int.MaxValue;
+						totalByteCount = Int32.MaxValue;
 						break;
 					}
 
@@ -353,7 +357,7 @@ public static int GetChars(this Encoding encoding, in ReadOnlySequence<byte> byt
 
 				do
 				{
-					remainingBytes.GetFirstSpan(out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+					GetFirstSpan(remainingBytes, out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
 					isFinalSegment = remainingBytes.IsSingleSegment;
 
 					int charsWrittenJustNow = decoder.GetChars(firstSpan, chars, flush: isFinalSegment);
@@ -366,11 +370,11 @@ public static int GetChars(this Encoding encoding, in ReadOnlySequence<byte> byt
 		}
 
 		/// <summary>
-		/// Decodes the specified <see cref="ReadOnlySequence{Byte}"/> into a <see cref="string"/> using the specified <see cref="Encoding"/>.
+		/// Decodes the specified <see cref="ReadOnlySequence{Byte}"/> into a <see cref="String"/> using the specified <see cref="Encoding"/>.
 		/// </summary>
 		/// <param name="encoding">The <see cref="Encoding"/> which represents how the data in <paramref name="bytes"/> is encoded.</param>
 		/// <param name="bytes">The <see cref="ReadOnlySequence{Byte}"/> to decode into characters.</param>
-		/// <returns>A <see cref="string"/> which represents the decoded contents of <paramref name="bytes"/>.</returns>
+		/// <returns>A <see cref="String"/> which represents the decoded contents of <paramref name="bytes"/>.</returns>
 		/// <exception cref="DecoderFallbackException">Thrown if <paramref name="bytes"/> contains data that cannot be decoded and <paramref name="encoding"/> is configured
 		/// to throw an exception when such data is seen.</exception>
 		public static string GetString(this Encoding encoding, in ReadOnlySequence<byte> bytes)
@@ -404,7 +408,7 @@ public static string GetString(this Encoding encoding, in ReadOnlySequence<byte>
 
 				do
 				{
-					remainingBytes.GetFirstSpan(out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+					GetFirstSpan(remainingBytes, out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
 					isFinalSegment = remainingBytes.IsSingleSegment;
 
 					int charCountThisIteration = decoder.GetCharCount(firstSpan, flush: isFinalSegment); // could throw ArgumentException if overflow would occur
@@ -419,7 +423,7 @@ public static string GetString(this Encoding encoding, in ReadOnlySequence<byte>
 						// This will end up throwing the expected OutOfMemoryException
 						// since strings are limited to under int.MaxValue elements in length.
 
-						totalCharCount = int.MaxValue;
+						totalCharCount = Int32.MaxValue;
 						break;
 					}
 
@@ -429,7 +433,7 @@ public static string GetString(this Encoding encoding, in ReadOnlySequence<byte>
 				// Now build up the string to return, then release all of our scratch buffers
 				// back to the shared pool.
 
-				return string.Create(totalCharCount, listOfSegments, (span, listOfSegments) =>
+				return String.Create(totalCharCount, listOfSegments, (span, listOfSegments) =>
 				{
 					foreach ((char[] array, int length) in listOfSegments)
 					{
@@ -524,7 +528,7 @@ public static void Convert(this Encoder encoder, in ReadOnlySequence<char> chars
 				// Process each segment individually. We need to run at least one iteration of the loop in case
 				// the Encoder has internal state.
 
-				remainingChars..GetFirstSpan(out ReadOnlySpan<char> firstSpan, out SequencePosition next);
+				GetFirstSpan(remainingChars, out ReadOnlySpan<char> firstSpan, out SequencePosition next);
 				isFinalSegment = remainingChars.IsSingleSegment;
 
 				Convert(encoder, firstSpan, writer, flush && isFinalSegment, out long bytesWrittenThisIteration, out completed);
@@ -618,7 +622,7 @@ public static void Convert(this Decoder decoder, in ReadOnlySequence<byte> bytes
 				// Process each segment individually. We need to run at least one iteration of the loop in case
 				// the Decoder has internal state.
 
-				remainingBytes.GetFirstSpan(out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+				GetFirstSpan(remainingBytes, out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
 				isFinalSegment = remainingBytes.IsSingleSegment;
 
 				Convert(decoder, firstSpan, writer, flush && isFinalSegment, out long charsWrittenThisIteration, out completed);
@@ -629,5 +633,37 @@ public static void Convert(this Decoder decoder, in ReadOnlySequence<byte> bytes
 
 			charsUsed = totalCharsWritten;
 		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static void GetFirstSpan<T>(ReadOnlySequence<T> sequence, out ReadOnlySpan<T> first, out SequencePosition next)
+		{
+			//	Port from https://github.com/dotnet/runtime/blob/a4c050ebf45a9745e2941863a8d7ae9c70ee88b2/src/libraries/System.Memory/src/System/Buffers/ReadOnlySequence.Helpers.cs#L635
+			next = default;
+
+			if (SequenceMarshal.TryGetArray(sequence, out var arraySegment))
+			{
+				first = arraySegment;
+			}
+			else if(SequenceMarshal.TryGetReadOnlySequenceSegment(sequence, out var segment, out var startIndex, out _, out var endIndex))
+			{
+				// In this pass, startIndex and endIndex should be same as internal _startInteger and _endInteger.
+				first = segment.Memory.Span;
+				if (!sequence.IsSingleSegment)
+				{
+					first = first.Slice(startIndex);
+					next = new SequencePosition(segment.Next, 0);
+				}
+				else
+				{
+					first = first.Slice(startIndex, endIndex - startIndex);
+				}
+			}
+			else
+			{
+				// This should fallback to "Slow-Pass" and default value handling.
+				// And they must be single segment, so next will be default.
+				first = sequence.FirstSpan;	
+			}
+		}
 	}
 }

From 0e508c938d0d2acac2bb2bfc1a395b144652a1cb Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Fri, 8 May 2020 02:34:22 +0900
Subject: [PATCH 10/82] Configure editorconfig

---
 .editorconfig | 140 +++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 122 insertions(+), 18 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index 73050d175..c28041544 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -42,18 +42,17 @@ csharp_style_var_when_type_is_apparent = true:suggestion
 csharp_style_var_elsewhere = true:suggestion
 dotnet_sort_system_directives_first = true
 csharp_space_between_method_declaration_name_and_open_parenthesis = false
-csharp_space_between_method_declaration_parameter_list_parentheses = true
+csharp_space_between_method_declaration_parameter_list_parentheses = false
 csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
 csharp_space_between_method_call_name_and_opening_parenthesis = false
-csharp_space_between_method_call_parameter_list_parentheses = true
+csharp_space_between_method_call_parameter_list_parentheses = false
 csharp_space_between_method_call_empty_parameter_list_parentheses = false
-csharp_space_between_parentheses = expressions,type_casts,control_flow_statements
 csharp_space_after_keywords_in_control_flow_statements = true
 csharp_space_after_cast = false
 csharp_space_around_declaration_statements = true
 csharp_space_before_open_square_brackets = false
 csharp_space_between_empty_square_brackets = false
-csharp_space_between_square_brackets = true
+csharp_space_between_square_brackets = false
 csharp_space_after_colon_in_inheritance_clause = true
 csharp_space_after_comma = true
 csharp_space_after_dot = false
@@ -62,7 +61,7 @@ csharp_space_before_colon_in_inheritance_clause = true
 csharp_space_before_comma = false
 csharp_space_before_dot = false
 csharp_space_before_semicolon_in_for_statement = false
-csharp_space_around_binary_operators = true
+csharp_space_around_binary_operators = false
 csharp_indent_braces = false
 csharp_indent_block_contents = true
 csharp_indent_switch_labels = true
@@ -75,17 +74,122 @@ csharp_preserve_single_line_statements = true
 csharp_new_line_before_open_brace = all
 csharp_new_line_between_query_expression_clauses = true
 
-# Disabled for Unity compatibility until 2017.1 RTM
 [*.cs]
-dotnet_style_null_propagation = false:warning
-csharp_style_expression_bodied_methods = false:warning
-csharp_style_expression_bodied_constructors = false:warning
-csharp_style_expression_bodied_operators = false:warning
-csharp_style_expression_bodied_properties = false:warning
-csharp_style_expression_bodied_indexers = false:warning
-csharp_style_expression_bodied_accessors = false:warning
-csharp_style_pattern_matching_over_is_with_cast_check = false:warning
-csharp_style_pattern_matching_over_as_with_null_check = false:warning
-csharp_style_inlined_variable_declaration = false:warning
-csharp_style_throw_expression = false:warning
-csharp_style_conditional_delegate_call = false:warning
+dotnet_style_null_propagation = true:suggestion
+csharp_style_expression_bodied_methods = true:suggestion
+csharp_style_expression_bodied_constructors = true:suggestion
+csharp_style_expression_bodied_operators = true:suggestion
+csharp_style_expression_bodied_properties = true:suggestion
+csharp_style_expression_bodied_indexers = true:suggestion
+csharp_style_expression_bodied_accessors = true:suggestion
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+csharp_style_throw_expression = true:suggestion
+csharp_style_conditional_delegate_call = true:suggestion
+
+# From https://github.com/dotnet/roslyn/blob/master/.editorconfig
+
+# Non-private static fields are PascalCase
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.style = non_private_static_field_style
+
+dotnet_naming_symbols.non_private_static_fields.applicable_kinds = field
+dotnet_naming_symbols.non_private_static_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected
+dotnet_naming_symbols.non_private_static_fields.required_modifiers = static
+
+dotnet_naming_style.non_private_static_field_style.capitalization = pascal_case
+
+# Non-private readonly fields are PascalCase
+dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.symbols = non_private_readonly_fields
+dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.style = non_private_readonly_field_style
+
+dotnet_naming_symbols.non_private_readonly_fields.applicable_kinds = field
+dotnet_naming_symbols.non_private_readonly_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected
+dotnet_naming_symbols.non_private_readonly_fields.required_modifiers = readonly
+
+dotnet_naming_style.non_private_readonly_field_style.capitalization = pascal_case
+
+# Constants are PascalCase
+dotnet_naming_rule.constants_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.constants_should_be_pascal_case.symbols = constants
+dotnet_naming_rule.constants_should_be_pascal_case.style = constant_style
+
+dotnet_naming_symbols.constants.applicable_kinds = field, local
+dotnet_naming_symbols.constants.required_modifiers = const
+
+dotnet_naming_style.constant_style.capitalization = pascal_case
+
+# Static fields are camelCase and start with s_
+dotnet_naming_rule.static_fields_should_be_camel_case.severity = suggestion
+dotnet_naming_rule.static_fields_should_be_camel_case.symbols = static_fields
+dotnet_naming_rule.static_fields_should_be_camel_case.style = static_field_style
+
+dotnet_naming_symbols.static_fields.applicable_kinds = field
+dotnet_naming_symbols.static_fields.required_modifiers = static
+
+dotnet_naming_style.static_field_style.capitalization = camel_case
+dotnet_naming_style.static_field_style.required_prefix = s_
+
+# Instance fields are camelCase and start with _
+dotnet_naming_rule.instance_fields_should_be_camel_case.severity = suggestion
+dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields
+dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style
+
+dotnet_naming_symbols.instance_fields.applicable_kinds = field
+
+dotnet_naming_style.instance_field_style.capitalization = camel_case
+dotnet_naming_style.instance_field_style.required_prefix = _
+
+# Locals and parameters are camelCase
+dotnet_naming_rule.locals_should_be_camel_case.severity = suggestion
+dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters
+dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style
+
+dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local
+
+dotnet_naming_style.camel_case_style.capitalization = camel_case
+
+# Local functions are PascalCase
+dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions
+dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style
+
+dotnet_naming_symbols.local_functions.applicable_kinds = local_function
+
+dotnet_naming_style.local_function_style.capitalization = pascal_case
+
+# By default, name items with PascalCase
+dotnet_naming_rule.members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members
+dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style
+
+dotnet_naming_symbols.all_members.applicable_kinds = *
+
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+
+# Blocks are allowed
+csharp_prefer_braces = true:silent
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = true
+
+# IDE0005: Remove unnecessary usings/imports
+dotnet_diagnostic.IDE0005.severity = warning
+
+# IDE0036: Order modifiers
+dotnet_diagnostic.IDE0036.severity = warning
+
+# IDE0040: Add accessibility modifiers
+dotnet_diagnostic.IDE0040.severity = warning
+
+# IDE0044: Make field readonly
+dotnet_diagnostic.IDE0044.severity = warning
+
+# CONSIDER: Are IDE0051 and IDE0052 too noisy to be warnings for IDE editing scenarios? Should they be made build-only warnings?
+# IDE0051: Remove unused private member
+dotnet_diagnostic.IDE0051.severity = warning
+
+# IDE0052: Remove unread private member
+dotnet_diagnostic.IDE0052.severity = warning
\ No newline at end of file

From ad8839b3a113dea2da8b1252d434a0f9dc0d0f7e Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Fri, 8 May 2020 02:37:42 +0900
Subject: [PATCH 11/82] Fix Directory.Build.props encoding

---
 Directory.Build.props | Bin 716 -> 349 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index 06e5a5521db7ba78d58e9b84e279a45c124c1f41..b87abed37ea7bc47c78afd73dbfaa95f89daacbc 100644
GIT binary patch
literal 349
zcmZvY!3u*g5Jc~O#S(<5P;GBLBuY`}u|o0Ii>*;oG?6qZ_3s;tf=XczyEE)#7?OOt
z7T!#~xD*r}!aV{e9<t)1p~&cZcSK3-kX*?pd+68!826qjJ)D&^{is+im7?a2QKhyV
zuvf*$jUvFVw=#VUlmf<p;*8x*L!y;E@$$CRwN%{}HR}t?NepRTkZ86h!d13rjF54)
ogt*?q@TVvj1%LFQ5EZMrU{!!o9ELYLBwD=x+K4uF*dTLPU;iX-ssI20

literal 716
zcma))K}*9x5QV?9;D1<(pe?lO%|mOE7CagdZ(eLof)djb8?k?0eY4vowWL)7n`P(C
z%r}qu{u(molQ#++AEZ>g^TL9X5gjfWaG}3bq-3u5XGKeLAFWxD(dSBvG1nY(#E?Wa
z7Q8BBu6THLst_Yf-(|&`Td%BHZmEKD;t4YK%BiJ#Ql&uU2r=V`Z$|1k<%F|Mv@NqM
zg%kJ4Ywg}q->GP3>XD1@{6KayN1UbbRGCOC`S%xBB8P2?sBfpak+*A6Bs_SY-K<@T
zdvz~FADx)Wm1-}G`O}`!RnE3EcfQL1^gXeb+KW`P*>0q|_vE#?JJ9#IInCep?#)!D
O3H!5uOB&7Z9s2>;mvIjO


From db229ae9f959ab08226bacb79f2fcda39550e9d3 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Fri, 8 May 2020 02:38:07 +0900
Subject: [PATCH 12/82] Define common properties

---
 Directory.Build.props | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Directory.Build.props b/Directory.Build.props
index b87abed37..58a34002b 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -4,5 +4,12 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net6'">
+    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ENCODING_EXTENSION;FEATURE_UTF8STRING</DefineConstants>
   </PropertyGroup>
 </Project>

From 51b0a935ccc43bca9b5ade62308d2ade9799855c Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Fri, 8 May 2020 02:39:24 +0900
Subject: [PATCH 13/82] WIP: initial v2 commit

This commit also includes _SampleObject to prove API concept.
---
 doc/v2.md                                     |   49 +
 .../InsufficientInputException.cs             |   23 +
 .../Internal/CollectionContext.cs             |   52 +
 .../Internal/CollectionItemIterator.cs        |   84 ++
 .../Internal/CollectionType.cs                |   67 +
 .../Internal/Decoder.Primitives.cs            | 1019 ++++++++++++++++
 .../Internal/Decoder.Primitives.tt            |  130 ++
 .../Internal/Decoder.Strings.cs               |  315 +++++
 .../Internal/Decoder.Strings.tt               |  194 +++
 src/MsgPack.Abstraction/Internal/Decoder.cs   |  226 ++++
 .../Internal/DecoderOptions.cs                |   47 +
 .../Internal/DecoderOptionsBuilder.cs         |   93 ++
 .../Internal/ElementType.cs                   |   25 +
 .../Internal/Encoder.Primitives.cs            |  228 ++++
 .../Internal/Encoder.Primitives.tt            |   65 +
 src/MsgPack.Abstraction/Internal/Encoder.cs   |  175 +++
 .../Internal/EncoderOptions.cs                |   35 +
 .../Internal/EncoderOptionsBuilder.cs         |   61 +
 src/MsgPack.Abstraction/Internal/Ensure.cs    |   45 +
 .../Internal/FormatFeatures.cs                |   20 +
 .../Internal/FormatFeaturesBuilder.cs         |   15 +
 .../Internal/MethodImplOptionsShim.cs         |   22 +
 .../Internal/OptionsDefaults.cs               |   22 +
 .../Internal/StreamBufferWriter.cs            |  112 ++
 .../Internal/StreamReadOnlyMemoryProvider.cs  |   57 +
 src/MsgPack.Abstraction/Internal/Throw.cs     |  150 +++
 .../Internal/Utf8EncodingNonBom.cs            |   21 +
 .../LimitExceededException.cs                 |   21 +
 .../MsgPack.Abstraction.csproj                |   49 +
 .../Properties/AssemblyInfo.cs                |    6 +
 .../Serialization/DeserializationOptions.cs   |   38 +
 .../DeserializationOptionsBuilder.cs          |   58 +
 .../DeserializationOperationContext.cs        |   65 +
 .../Internal/IObjectSerializer`1.cs           |   20 +
 .../Internal/SerializationOperationContext.cs |   50 +
 .../Serialization/SerializationOptions.cs     |   26 +
 .../SerializationOptionsBuilder.cs            |   24 +
 .../Serialization/Serializer`1.cs             |  112 ++
 .../MsgPack.Compatibility.csproj              |    7 +
 .../Internal/CurrentMessagePackEncoder.cs     |  163 +++
 .../Internal/LegacyMessagePackEncoder.cs      |   45 +
 src/MsgPack.Core/Internal/MemoryExtensions.cs |   34 +
 .../MessagePackDecoder.CollectionHeaders.cs   |  171 +++
 .../Internal/MessagePackDecoder.DecodeItem.cs |  355 ++++++
 .../Internal/MessagePackDecoder.Extension.cs  |  138 +++
 .../Internal/MessagePackDecoder.Integers.cs   |  449 +++++++
 .../Internal/MessagePackDecoder.Integers.tt   |  262 ++++
 .../Internal/MessagePackDecoder.Iteration.cs  |   67 +
 .../Internal/MessagePackDecoder.Nullables.cs  |  161 +++
 .../Internal/MessagePackDecoder.Nullables.tt  |   55 +
 .../MessagePackDecoder.Number.ttinclude       |   32 +
 .../Internal/MessagePackDecoder.Reals.cs      |  223 ++++
 .../Internal/MessagePackDecoder.Reals.tt      |  100 ++
 .../Internal/MessagePackDecoder.SkipDrain.cs  |  281 +++++
 .../Internal/MessagePackDecoder.Strings.cs    |  283 +++++
 .../Internal/MessagePackDecoder.cs            |  184 +++
 .../Internal/MessagePackDecoderOptions.cs     |   12 +
 .../MessagePackDecoderOptionsBuilder.cs       |   13 +
 .../Internal/MessagePackEncoder.Integers.cs   |  190 +++
 .../Internal/MessagePackEncoder.Integers.tt   |  137 +++
 .../Internal/MessagePackEncoder.Strings.cs    |  272 +++++
 .../Internal/MessagePackEncoder.Strings.tt    |  173 +++
 .../Internal/MessagePackEncoder.cs            |  249 ++++
 .../Internal/MessagePackEncoderOptions.cs     |   11 +
 .../MessagePackEncoderOptionsBuilder.cs       |   13 +
 src/MsgPack.Core/Internal/MessagePackThrow.cs |   45 +
 .../Internal/MsgPackStringTrie`1.cs           |  299 +++++
 src/MsgPack.Core/MsgPack.Core.csproj          |   71 ++
 .../System.Text/EncodingExtensions.cs         |   94 +-
 src/MsgPack.Core/_SampleObject.cs             | 1085 +++++++++++++++++
 .../MsgPack.Extensions.csproj                 |    7 +
 src/MsgPack.Json/Json/JsonEncoder.cs          |  784 ++++++++++++
 src/MsgPack.Json/MsgPack.Json.csproj          |   21 +
 .../MsgPack.Serialization.Extensions.csproj   |    7 +
 .../MsgPack.Serialization.Reflection.csproj   |    7 +
 ...Pack.Serialization.SourceGeneration.csproj |    7 +
 .../MsgPack.Serialization.csproj              |   15 +
 77 files changed, 10301 insertions(+), 42 deletions(-)
 create mode 100644 doc/v2.md
 create mode 100644 src/MsgPack.Abstraction/InsufficientInputException.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/CollectionContext.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/CollectionType.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt
 create mode 100644 src/MsgPack.Abstraction/Internal/Decoder.Strings.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Decoder.Strings.tt
 create mode 100644 src/MsgPack.Abstraction/Internal/Decoder.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/DecoderOptions.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/ElementType.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt
 create mode 100644 src/MsgPack.Abstraction/Internal/Encoder.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/EncoderOptions.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Ensure.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FormatFeatures.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/MethodImplOptionsShim.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Throw.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/Utf8EncodingNonBom.cs
 create mode 100644 src/MsgPack.Abstraction/LimitExceededException.cs
 create mode 100644 src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
 create mode 100644 src/MsgPack.Abstraction/Properties/AssemblyInfo.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Serializer`1.cs
 create mode 100644 src/MsgPack.Compatibility/MsgPack.Compatibility.csproj
 create mode 100644 src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
 create mode 100644 src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs
 create mode 100644 src/MsgPack.Core/Internal/MemoryExtensions.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoder.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoder.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs
 create mode 100644 src/MsgPack.Core/Internal/MessagePackThrow.cs
 create mode 100644 src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs
 create mode 100644 src/MsgPack.Core/MsgPack.Core.csproj
 create mode 100644 src/MsgPack.Core/_SampleObject.cs
 create mode 100644 src/MsgPack.Extensions/MsgPack.Extensions.csproj
 create mode 100644 src/MsgPack.Json/Json/JsonEncoder.cs
 create mode 100644 src/MsgPack.Json/MsgPack.Json.csproj
 create mode 100644 src/MsgPack.Serialization.Extensions/MsgPack.Serialization.Extensions.csproj
 create mode 100644 src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
 create mode 100644 src/MsgPack.Serialization.SourceGeneration/MsgPack.Serialization.SourceGeneration.csproj
 create mode 100644 src/MsgPack.Serialization/MsgPack.Serialization.csproj

diff --git a/doc/v2.md b/doc/v2.md
new file mode 100644
index 000000000..7f1c3ddd7
--- /dev/null
+++ b/doc/v2.md
@@ -0,0 +1,49 @@
+MessagePack for CLI v2
+===
+
+Goals
+---
+
+* Supports .NET Framework 3.5 and 4.8, .NET Core 2.1 and 3.1, Xamarin Android and iOS, UWP, Unity.
+* Supports stream based serialization/deserialization for large blobs like v1.
+* Supports various format as possible including JSON, CBOF, protbuf, etc.
+* Keep high level API compatiblity with v1.
+* Improve performance.
+
+Non-Goals
+---
+
+* 100% API compatibility with v1.
+  * Custom `Packer` and custom `Unpacker` will not be supported.
+* ABI compatibility with v1.
+* Keep performance for compatibility layer espetially custom serializer, IPackable/IUnpackable, and async operation.
+* Legacy platform support including Silverlight, .NET Standard 1.x, etc.
+* High performance in old platform such as .NET Framework and .NET Core 2.1.
+* 100% Unity stability.
+
+Status
+---
+
+* [ ] Encoder/Decoder layer utlizing `ReadOnlySequence<byte>` and `IBufferWriter<byte>`
+* [ ] Simple JSON serializer with some tweak points for design verification. \[in progress]
+* [ ] Debugging features
+* [ ] Reflection based object serializer
+* [ ] Code generator w/ CodDOM or Roslyn
+* [ ] ILGenerator based object serializer
+* [ ] `SerializationContext`
+* [ ] Known serializers
+* [ ] Timestamp
+* [ ] Multi demensional array
+* [ ] Polymorphism
+* [ ] v1 compatiblity layer
+  * [ ] `MessagePackSerializer<T>`
+  * [ ] `MessagePackObject`
+  * [ ] `Packer` and `Unpacker`
+  * [ ] `IPackable` and `IUnpackable`
+  * other stuff...
+* [ ] msgpack for C# compatiblity such as LZ4 support
+* [ ] More formats
+  * [ ] Completes JSON serializer
+  * [ ] CBOF serializer
+  * [ ] Protobuf serializer
+  * other formats...
diff --git a/src/MsgPack.Abstraction/InsufficientInputException.cs b/src/MsgPack.Abstraction/InsufficientInputException.cs
new file mode 100644
index 000000000..ea02c15ae
--- /dev/null
+++ b/src/MsgPack.Abstraction/InsufficientInputException.cs
@@ -0,0 +1,23 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack
+{
+	/// <summary>
+	///		An exception thrown if there are no more inputs when be requested.
+	/// </summary>
+	public sealed class InsufficientInputException : Exception
+	{
+		public InsufficientInputException()
+			: this("There are no more inputs.") { }
+
+		public InsufficientInputException(string? message)
+			: base(message) { }
+
+		public InsufficientInputException(string? message, Exception? innerException)
+			: base(message, innerException) { }
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/CollectionContext.cs b/src/MsgPack.Abstraction/Internal/CollectionContext.cs
new file mode 100644
index 000000000..8b2cdb5d5
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/CollectionContext.cs
@@ -0,0 +1,52 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Serialization;
+
+namespace MsgPack.Internal
+{
+	public partial struct CollectionContext
+	{
+		public static CollectionContext Default =>
+			new CollectionContext(
+				DeserializationOptionsBuilder.DefaultMaxArrayLength,
+				DeserializationOptionsBuilder.DefaultMaxMapCount,
+				DeserializationOptionsBuilder.DefaultMaxDepth,
+				currentDepth: 0
+			);
+
+		public int MaxArrayLength { get; }
+		public int MaxMapCount { get; }
+		public int MaxDepth { get; }
+		public int CurrentDepth { get; private set; }
+
+		internal CollectionContext(int maxArrayLength, int maxMapCount, int maxDepth, int currentDepth)
+		{
+			this.MaxArrayLength = maxArrayLength;
+			this.MaxMapCount = maxMapCount;
+			this.MaxDepth = Ensure.IsNotLessThan(maxDepth, 1);
+			this.CurrentDepth = currentDepth;
+		}
+
+		public int IncrementDepth()
+		{
+			if (this.CurrentDepth == this.MaxDepth)
+			{
+				Throw.DepthExeeded(this.CurrentDepth, this.MaxDepth);
+			}
+
+			return this.CurrentDepth++;
+		}
+
+		public int DecrementDepth()
+		{
+			if (this.CurrentDepth == 0)
+			{
+				Throw.DepthUnderflow();
+			}
+
+			return this.CurrentDepth--;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
new file mode 100644
index 000000000..ddf24be47
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
@@ -0,0 +1,84 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	public struct CollectionItemIterator
+	{
+		public delegate bool CollectionEndDetection(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint);
+
+		private readonly long _itemsCount;
+		private long _nextItemIndex;
+		private readonly CollectionEndDetection _collectionEnds;
+
+		public CollectionItemIterator(
+			CollectionEndDetection moveNext,
+			long itemsCount
+		)
+		{
+			this._collectionEnds = Ensure.NotNull(moveNext);
+			this._itemsCount = itemsCount;
+			this._nextItemIndex = 0;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool CollectionEnds(in SequenceReader<byte> source)
+		{
+			var result = this._collectionEnds(source, ref this._nextItemIndex, this._itemsCount, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDetectCollectionEnds(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool CollectionEnds(in SequenceReader<byte> source, out int requestHint)
+			=> this._collectionEnds(source, ref this._nextItemIndex, this._itemsCount, out requestHint);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool CollectionEnds(ReadOnlyMemory<byte> source, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(source));
+			return this.CollectionEnds(reader, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void Drain(in SequenceReader<byte> source)
+		{
+			if (!this.Drain(source, out var requestHint))
+			{
+				Throw.InsufficientInputForDrainCollectionItems(source.Consumed, requestHint);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool Drain(in SequenceReader<byte> source, out int requestHint)
+		{
+			while (!this.CollectionEnds(source, out requestHint))
+			{
+				if (requestHint != 0)
+				{
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool Drain(ref ReadOnlyMemory<byte> source, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(source));
+			var ends = this.Drain(reader, out requestHint);
+			source = source.Slice((int)reader.Consumed);
+			return ends;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/CollectionType.cs b/src/MsgPack.Abstraction/Internal/CollectionType.cs
new file mode 100644
index 000000000..1875b8472
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/CollectionType.cs
@@ -0,0 +1,67 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Represents collection type.
+	/// </summary>
+	public readonly struct CollectionType : IEquatable<CollectionType>
+	{
+		public static readonly CollectionType None = default;
+		public static readonly CollectionType Array = new CollectionType(1);
+		public static readonly CollectionType Map = new CollectionType(2);
+
+		private readonly int _type;
+
+		public bool IsArray
+		{
+			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+			get => this._type == 1;
+		}
+
+		public bool IsMap
+		{
+			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+			get => this._type == 2;
+		}
+
+		public bool IsNone
+		{
+			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+			get => this._type == 0;
+		}
+
+		private CollectionType(int type)
+		{
+			this._type = type;
+		}
+
+		public override bool Equals(object? obj)
+			=> obj is CollectionType other ? this.Equals(other) : false;
+
+		public bool Equals(CollectionType other)
+			=> this._type == other._type;
+
+		public override int GetHashCode()
+			=> this._type;
+
+		public override string ToString()
+			=> this._type switch
+			{
+				1 => "Array",
+				2 => "Map",
+				_ => String.Empty
+			};
+
+		public static bool operator ==(CollectionType left, CollectionType right)
+			=> left.Equals(right);
+
+		public static bool operator !=(CollectionType left, CollectionType right)
+			=> !left.Equals(right);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs b/src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs
new file mode 100644
index 000000000..9d4066b1a
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs
@@ -0,0 +1,1019 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class Decoder
+	{
+		/// <summary>
+		///		Decodes <see cref="Byte" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Byte DecodeByte(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeByte(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Byte), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Byte" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Byte DecodeByte(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Byte" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Byte? DecodeNullableByte(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableByte(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Byte), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Byte" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Byte? DecodeNullableByte(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="Int16" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Int16 DecodeInt16(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeInt16(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Int16), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Int16" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Int16 DecodeInt16(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Int16" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Int16? DecodeNullableInt16(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableInt16(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Int16), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Int16" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Int16? DecodeNullableInt16(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="Int32" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Int32 DecodeInt32(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeInt32(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Int32), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Int32" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Int32 DecodeInt32(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Int32" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Int32? DecodeNullableInt32(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableInt32(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Int32), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Int32" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Int32? DecodeNullableInt32(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="Int64" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Int64 DecodeInt64(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeInt64(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Int64), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Int64" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Int64 DecodeInt64(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Int64" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Int64? DecodeNullableInt64(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableInt64(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Int64), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Int64" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Int64? DecodeNullableInt64(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="SByte" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public SByte DecodeSByte(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeSByte(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(SByte), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="SByte" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract SByte DecodeSByte(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="SByte" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public SByte? DecodeNullableSByte(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableSByte(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(SByte), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="SByte" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract SByte? DecodeNullableSByte(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="UInt16" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public UInt16 DecodeUInt16(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeUInt16(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(UInt16), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="UInt16" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract UInt16 DecodeUInt16(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="UInt16" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public UInt16? DecodeNullableUInt16(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableUInt16(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(UInt16), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="UInt16" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract UInt16? DecodeNullableUInt16(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="UInt32" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public UInt32 DecodeUInt32(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeUInt32(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(UInt32), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="UInt32" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract UInt32 DecodeUInt32(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="UInt32" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public UInt32? DecodeNullableUInt32(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableUInt32(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(UInt32), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="UInt32" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract UInt32? DecodeNullableUInt32(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="UInt64" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public UInt64 DecodeUInt64(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeUInt64(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(UInt64), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="UInt64" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract UInt64 DecodeUInt64(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="UInt64" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public UInt64? DecodeNullableUInt64(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableUInt64(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(UInt64), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="UInt64" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract UInt64? DecodeNullableUInt64(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="Single" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Single DecodeSingle(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeSingle(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Single), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Single" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Single DecodeSingle(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Single" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Single? DecodeNullableSingle(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableSingle(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Single), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Single" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Single? DecodeNullableSingle(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="Double" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Double DecodeDouble(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeDouble(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Double), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Double" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Double DecodeDouble(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Double" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Double? DecodeNullableDouble(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableDouble(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Double), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Double" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Double? DecodeNullableDouble(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes <see cref="Boolean" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Boolean DecodeBoolean(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeBoolean(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Boolean), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Boolean" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Boolean DecodeBoolean(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="Boolean" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Boolean? DecodeNullableBoolean(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullableBoolean(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(Boolean), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="Boolean" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Boolean? DecodeNullableBoolean(in SequenceReader<byte> source, out int requestHint);
+
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt b/src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt
new file mode 100644
index 000000000..4a4be9e47
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt
@@ -0,0 +1,130 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class Decoder
+	{
+<#
+foreach (var outputType in new [] {
+	"Byte",
+	"Int16",
+	"Int32",
+	"Int64",
+	"SByte",
+	"UInt16",
+	"UInt32",
+	"UInt64",
+	"Single",
+	"Double",
+	"Boolean"
+})
+{
+#>
+		/// <summary>
+		///		Decodes <see cref="<#= outputType #>" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public <#= outputType #> Decode<#= outputType #>(in SequenceReader<byte> source)
+		{
+			var result = this.Decode<#= outputType #>(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(<#= outputType #>), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="<#= outputType #>" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract <#= outputType #> Decode<#= outputType #>(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Encodes <see cref="<#= outputType #>" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public <#= outputType #>? DecodeNullable<#= outputType #>(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeNullable<#= outputType #>(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(<#= outputType #>), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Encodes <see cref="<#= outputType #>" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract <#= outputType #>? DecodeNullable<#= outputType #>(in SequenceReader<byte> source, out int requestHint);
+
+<#
+}
+#>
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Strings.cs b/src/MsgPack.Abstraction/Internal/Decoder.Strings.cs
new file mode 100644
index 000000000..78a9715d2
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Decoder.Strings.cs
@@ -0,0 +1,315 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	partial class Decoder
+	{
+		/// <summary>
+		///		Decodes <see cref="String" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public String DecodeString(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeString(source, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForString(source.Consumed, typeof(String), encoding, requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="String" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract String? DecodeString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes <see cref="String" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public String? DecodeNullableString(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullableString(source, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForString(source.Consumed, typeof(String), encoding, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="String" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract String? DecodeNullableString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+
+#if FEATURE_UTF8STRING
+
+		/// <summary>
+		///		Decodes <see cref="Utf8String" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Utf8String DecodeUtf8String(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeUtf8String(source, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForUtf8String(source.Consumed, typeof(Utf8String), encoding, requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Utf8String" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract Utf8String? DecodeUtf8String(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes <see cref="Utf8String" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Utf8String? DecodeNullableUtf8String(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullableUtf8String(source, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForUtf8String(source.Consumed, typeof(Utf8String), encoding, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="Utf8String" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract Utf8String? DecodeNullableUtf8String(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+
+#endif // FEATURE_UTF8STRING
+
+		/// <summary>
+		///		Decodes <see cref="byte[]" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public byte[] DecodeBinary(in SequenceReader<byte> source, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeBinary(source, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(byte[]), requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="byte[]" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract byte[]? DecodeBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes <see cref="byte[]" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public byte[]? DecodeNullableBinary(in SequenceReader<byte> source, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullableBinary(source, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(byte[]), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="byte[]" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract byte[]? DecodeNullableBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
+
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Strings.tt b/src/MsgPack.Abstraction/Internal/Decoder.Strings.tt
new file mode 100644
index 000000000..4b7a3da9e
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Decoder.Strings.tt
@@ -0,0 +1,194 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	partial class Decoder
+	{
+<#
+foreach (var spec in new [] {
+	new
+	{
+		Name = "String", Type = "String", ThrowSuffix = "ForString",
+		ExtraParameters = "Encoding? encoding = null, ",
+		ExtraParameterDocs = new [] { "<param name=\"encoding\">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>" },
+		ExtraArguments = "encoding, ", IfDef = String.Empty
+	},
+	new
+	{
+		Name = "Utf8String", Type = "Utf8String", ThrowSuffix = "ForUtf8String",
+		ExtraParameters = "Encoding? encoding = null, ",
+		ExtraParameterDocs = new [] { "<param name=\"encoding\">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>" },
+		ExtraArguments = "encoding, ", IfDef = "FEATURE_UTF8STRING"
+	},
+	new
+	{
+		Name = "Binary", Type = "byte[]", ThrowSuffix = String.Empty,
+		ExtraParameters = String.Empty,
+		ExtraParameterDocs = Array.Empty<string>(),
+		ExtraArguments = String.Empty, IfDef = String.Empty
+	},
+})
+{
+	if (!String.IsNullOrEmpty(spec.IfDef))
+	{
+#>
+
+#if <#= spec.IfDef #>
+
+<#
+	}
+#>
+		/// <summary>
+		///		Decodes <see cref="<#= spec.Type #>" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public <#= spec.Type #> Decode<#= spec.Name #>(in SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
+		{
+			var result = this.Decode<#= spec.Name #>(source, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput<#= spec.ThrowSuffix #>(source.Consumed, typeof(<#= spec.Type #>), <#= spec.ExtraArguments #>requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="<#= spec.Type #>" /> value from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract <#= spec.Type #>? Decode<#= spec.Name #>(in SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes <see cref="<#= spec.Type #>" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public <#= spec.Type #>? DecodeNullable<#= spec.Name #>(in SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullable<#= spec.Name #>(source, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput<#= spec.ThrowSuffix #>(source.Consumed, typeof(<#= spec.Type #>), <#= spec.ExtraArguments #>requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes <see cref="<#= spec.Type #>" /> value or <c>null</c> from specified sequence.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <return>
+		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
+		///		If this value is default, <paramref name="source" /> will not be advanced.
+		/// </return>
+		/// <remarks>
+		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
+		/// </remarks>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract <#= spec.Type #>? DecodeNullable<#= spec.Name #>(in SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
+
+<#
+	if (!String.IsNullOrEmpty(spec.IfDef))
+	{
+#>
+
+#endif // <#= spec.IfDef #>
+
+<#
+	}
+}
+#>
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.cs b/src/MsgPack.Abstraction/Internal/Decoder.cs
new file mode 100644
index 000000000..1b5c814da
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Decoder.cs
@@ -0,0 +1,226 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	public abstract partial class Decoder
+#warning TODO: Use 'Try' prefix for published APIs which can return 'requestHint'.
+
+	{
+		public FormatFeatures FormatFeatures { get; }
+
+		public DecoderOptions Options { get; }
+
+		protected Decoder(DecoderOptions options, FormatFeatures formatFeatures)
+		{
+			this.Options = Ensure.NotNull(options);
+			this.FormatFeatures = Ensure.NotNull(formatFeatures);
+		}
+
+		public void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, CancellationToken cancellationToken = default)
+		{
+			this.Skip(source, collectionContext, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForSkip(source.Consumed, requestHint);
+			}
+		}
+
+		public abstract void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool TryPeek(in SequenceReader<byte> source, out byte value) => source.TryRead(out value);
+
+		public abstract ElementType DecodeItem(in SequenceReader<byte> source, out ReadOnlySequence<byte> valueOrLength, out int requestHint, CancellationToken cancellationToken = default);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, CancellationToken cancellationToken = default)
+		{
+			if (!this.GetRawString(source, out rawString, out var requestHint, cancellationToken))
+			{
+				Throw.InsufficientInputForRawString(source.Consumed, requestHint);
+			}
+		}
+
+		public abstract bool GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes current data as array or map header, and returns the items count if known.
+		/// </summary>
+		/// <param name="source">Reader of source byte sequence. If and only if this method succeeds, the reader will be advanced.</param>
+		/// <param name="itemsCount">Items count if known; <c>-1</c> if underlying format does not contain any count information; <c>0</c> if underlying format is not an array nor a map.</param>
+		/// <returns>
+		///		<see cref="ElementType.Array"/> for array, <see cref="ElementType.Map"/> for map (dictionary).
+		///		This method does not return anything else, but may throw an exception.
+		///	</returns>
+		///	<exception cref="MessageTypeException">The decoded value is not an array nor a map.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount)
+		{
+			var result = this.DecodeArrayOrMapHeader(source, out itemsCount, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeArrayOrMapHeader(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes current data as array or map header, and returns the items count if known.
+		/// </summary>
+		/// <param name="source">Reader of source byte sequence. If and only if this method succeeds, the reader will be advanced.</param>
+		/// <param name="itemsCount">Items count if known; <c>-1</c> if underlying format does not contain any count information; <c>0</c> if underlying format is not an array nor a map.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		///	</param>
+		/// <returns>
+		///		<see cref="ElementType.Array"/> for array, <see cref="ElementType.Map"/> for map (dictionary), or <see cref="ElementType.None"/> if there were not enough bytes to decode.
+		///		This method does not return anything else, but may throw an exception.
+		///	</returns>
+		///	<exception cref="MessageTypeException">The decoded value is not an array nor a map.</exception>
+		public abstract CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount, out int requestHint);
+
+		/// <summary>
+		///		Decodes current data as array header, and returns the items count if known.
+		/// </summary>
+		/// <param name="source">Reader of source byte sequence. If and only if this method succeeds, the reader will be advanced.</param>
+		/// <returns>
+		///		Items count if known; <c>-1</c> if underlying format does not contain any count information.
+		///		Note that <c>0</c> is valid value when the array is empty.
+		///	</returns>
+		///	<exception cref="MessageTypeException">The decoded value is not an array.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public long DecodeArrayHeader(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeArrayHeader(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeArrayHeader(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes current data as array header, and returns the items count if known.
+		/// </summary>
+		/// <param name="source">Reader of source byte sequence. If and only if this method succeeds, the reader will be advanced.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		///	</param>
+		/// <returns>
+		///		Items count if known; <c>-1</c> if underlying format does not contain any count information.
+		///		Note that <c>0</c> is valid value when the array is empty.
+		///	</returns>
+		///	<exception cref="MessageTypeException">The decoded value is not an array.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract long DecodeArrayHeader(in SequenceReader<byte> source, out int requestHint);
+
+		/// <summary>
+		///		Decodes current data as map header, and returns the items count if known.
+		/// </summary>
+		/// <param name="source">Reader of source byte sequence. If and only if this method succeeds, the reader will be advanced.</param>
+		/// <returns>
+		///		Items count if known; <c>-1</c> if underlying format does not contain any count information.
+		///		Note that <c>0</c> is valid value when the map is empty.
+		///	</returns>
+		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public long DecodeMapHeader(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeMapHeader(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeMapHeader(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes current data as map header, and returns the items count if known.
+		/// </summary>
+		/// <param name="source">Reader of source byte sequence. If and only if this method succeeds, the reader will be advanced.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		///	</param>
+		/// <returns>
+		///		Items count if known; <c>-1</c> if underlying format does not contain any count information.
+		///		Note that <c>0</c> is valid value when the map is empty.
+		///	</returns>
+		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
+		public abstract long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint);
+
+		public virtual void DecodeExtension(in SequenceReader<byte> source, out byte typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			Throw.ExtensionsIsNotSupported();
+			// never
+			body = default;
+			requestHint = -1;
+			typeCode = default;
+		}
+
+		public CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator)
+		{
+			var result = this.DecodeArrayOrMap(source, out iterator, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeArrayOrMapHeader(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		public abstract CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint);
+
+		public CollectionItemIterator DecodeArray(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeArray(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeArrayHeader(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		public abstract CollectionItemIterator DecodeArray(in SequenceReader<byte> source, out int requestHint);
+
+		public CollectionItemIterator DecodeMap(in SequenceReader<byte> source)
+		{
+			var result = this.DecodeMap(source, out var requestHint);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeMapHeader(source.Consumed, requestHint);
+			}
+
+			return result;
+		}
+
+		public abstract CollectionItemIterator DecodeMap(in SequenceReader<byte> source, out int requestHint);
+
+		public void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, CancellationToken cancellationToken = default)
+		{
+			this.Drain(source, collectionContext, itemsCount, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForDecodeMapHeader(source.Consumed, requestHint);
+			}
+		}
+
+		public abstract void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/DecoderOptions.cs b/src/MsgPack.Abstraction/Internal/DecoderOptions.cs
new file mode 100644
index 000000000..9e333bc2c
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/DecoderOptions.cs
@@ -0,0 +1,47 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	public abstract class DecoderOptions
+	{
+		public bool CanTreatRealAsInteger { get; }
+
+		public int CancellationSupportThreshold { get; }
+
+		public ArrayPool<byte> ByteBufferPool { get; }
+
+		public ArrayPool<char> CharBufferPool { get; }
+
+		public int MaxByteBufferLength { get; }
+
+		public int MaxCharBufferLength { get; }
+
+		public int MaxNumberLengthInBytes { get; }
+
+		public int MaxStringLengthInBytes { get; }
+
+		public int MaxBinaryLengthInBytes { get; }
+
+		public bool ClearsBuffer { get; }
+
+		protected DecoderOptions(DecoderOptionsBuilder builder)
+		{
+			builder = Ensure.NotNull(builder);
+
+			this.CanTreatRealAsInteger = builder.CanTreatRealAsInteger;
+			this.CancellationSupportThreshold = builder.CancellationSupportThreshold;
+			this.ClearsBuffer = builder.ClearsBuffer;
+			this.ByteBufferPool = builder.ByteBufferPool;
+			this.CharBufferPool = builder.CharBufferPool;
+			this.MaxByteBufferLength = builder.MaxByteBufferLength;
+			this.MaxCharBufferLength = builder.MaxCharBufferLength;
+			this.MaxNumberLengthInBytes = builder.MaxNumberLengthInBytes;
+			this.MaxStringLengthInBytes = builder.MaxStringLengthInBytes;
+			this.MaxBinaryLengthInBytes = builder.MaxBinaryLengthInBytes;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
new file mode 100644
index 000000000..893cff502
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
@@ -0,0 +1,93 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	public abstract class DecoderOptionsBuilder
+	{
+		public bool CanTreatRealAsInteger { get; set; } = OptionsDefaults.CanTreatRealAsInteger;
+
+		private int _cancellationSupportThreshold = OptionsDefaults.CancellationSupportThreshold;
+
+		public int CancellationSupportThreshold
+		{
+			get => this._cancellationSupportThreshold;
+			set => this._cancellationSupportThreshold = Ensure.IsNotLessThan(value, 1);
+		}
+
+		private int _maxNumberLengthInBytes = OptionsDefaults.MaxNumberLengthInBytes;
+
+		public int MaxNumberLengthInBytes
+		{
+			get => this._maxNumberLengthInBytes;
+			set => this._maxNumberLengthInBytes = Ensure.IsNotLessThan(value, 1);
+		}
+
+		private int _maxStringLengthInBytes = OptionsDefaults.MaxStringLengthInBytes;
+
+		public int MaxStringLengthInBytes
+	{
+			get => this._maxStringLengthInBytes;
+			set => this._maxStringLengthInBytes = Ensure.IsNotLessThan(value, 1);
+		}
+
+		private int _naxBinaryLengthInBytes = OptionsDefaults.MaxBinaryLengthInBytes;
+
+		public int MaxBinaryLengthInBytes
+		{
+			get => this._naxBinaryLengthInBytes;
+			set => this._naxBinaryLengthInBytes = Ensure.IsNotLessThan(value, 1);
+		}
+
+		private int _maxByteBufferLength = OptionsDefaults.MaxByteBufferLength;
+
+		public int MaxByteBufferLength
+		{
+			get => this._maxByteBufferLength;
+			set => this._maxByteBufferLength = Ensure.IsNotLessThan(value, 4);
+		}
+
+		private int _maxCharBufferLength = OptionsDefaults.MaxCharBufferLength;
+
+		public int MaxCharBufferLength
+		{
+			get => this._maxCharBufferLength;
+			set => this._maxCharBufferLength = Ensure.IsNotLessThan(value, 2);
+		}
+
+		private ArrayPool<byte> _byteBufferPool = OptionsDefaults.ByteBufferPool;
+
+		public ArrayPool<byte> ByteBufferPool
+		{
+			get => this._byteBufferPool;
+			set => this._byteBufferPool = Ensure.NotNull(value);
+		}
+
+		private ArrayPool<char> _charBufferPool = OptionsDefaults.CharBufferPool;
+
+		public ArrayPool<char> CharBufferPool
+		{
+			get => this._charBufferPool;
+			set => this._charBufferPool = Ensure.NotNull(value);
+		}
+
+		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
+
+		protected DecoderOptionsBuilder() { }
+
+		public DecoderOptionsBuilder WithoutBufferClear()
+		{
+			this.ClearsBuffer = false;
+			return this;
+		}
+
+		public DecoderOptionsBuilder ProhibitTreatRealAsInteger()
+		{
+			this.CanTreatRealAsInteger = false;
+			return this;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/ElementType.cs b/src/MsgPack.Abstraction/Internal/ElementType.cs
new file mode 100644
index 000000000..4c69521a5
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/ElementType.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace MsgPack.Internal
+{
+	public enum ElementType
+	{
+		None = 0,
+		Int32 = 1,
+		Int64 = 2,
+		UInt64 = 3,
+		Single = 4,
+		Double = 5,
+		True = 6,
+		False = 7,
+		Null = 8,
+		Array = 0x11,
+		Map = 0x12,
+		String = 0x31,
+		Binary = 0x32,
+		Extension = 0x41,
+		Whitespace = 0x51,
+		Comment = 0x52,
+		OtherTrivia = 0x5F
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs b/src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs
new file mode 100644
index 000000000..3b66f1243
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs
@@ -0,0 +1,228 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class Encoder
+	{
+		/// <summary>
+		///		Encodes <see cref="Int32" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeInt32(Int32 value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="Int32" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeInt32(Int32? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeInt32(value.GetValueOrDefault(), buffer);
+			}
+		}
+		/// <summary>
+		///		Encodes <see cref="Int64" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeInt64(Int64 value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="Int64" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeInt64(Int64? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeInt64(value.GetValueOrDefault(), buffer);
+			}
+		}
+		/// <summary>
+		///		Encodes <see cref="UInt32" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeUInt32(UInt32 value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="UInt32" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeUInt32(UInt32? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeUInt32(value.GetValueOrDefault(), buffer);
+			}
+		}
+		/// <summary>
+		///		Encodes <see cref="UInt64" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeUInt64(UInt64 value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="UInt64" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeUInt64(UInt64? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeUInt64(value.GetValueOrDefault(), buffer);
+			}
+		}
+		/// <summary>
+		///		Encodes <see cref="Single" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeSingle(Single value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="Single" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeSingle(Single? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeSingle(value.GetValueOrDefault(), buffer);
+			}
+		}
+		/// <summary>
+		///		Encodes <see cref="Double" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeDouble(Double value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="Double" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeDouble(Double? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeDouble(value.GetValueOrDefault(), buffer);
+			}
+		}
+		/// <summary>
+		///		Encodes <see cref="Boolean" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void EncodeBoolean(Boolean value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="Boolean" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeBoolean(Boolean? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.EncodeBoolean(value.GetValueOrDefault(), buffer);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt b/src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt
new file mode 100644
index 000000000..c94109f3e
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt
@@ -0,0 +1,65 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class Encoder
+	{
+<#
+foreach (var inputType in new [] {
+	"Int32",
+	"Int64",
+	"UInt32",
+	"UInt64",
+	"Single",
+	"Double",
+	"Boolean"
+})
+{
+#>
+		/// <summary>
+		///		Encodes <see cref="<#= inputType #>" /> value to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		/// <exception cref="ArgumentNullException"><paramref name="buffer" /> is <c>null</c>.</exception>
+		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
+		public abstract void Encode<#= inputType #>(<#= inputType #> value, IBufferWriter<byte> buffer);
+
+		/// <summary>
+		///		Encodes <see cref="<#= inputType #>" /> value or <c>null</c> to specified buffer.
+		///		The implementation will choose most compact format.
+		/// </summary>
+		/// <param name="value">Value to be encoded.</param>
+		/// <param name="buffer"><see cref="IBufferWriter{T}">IBufferWriter&lt;byte&gt;</see>.</param>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void Encode<#= inputType #>(<#= inputType #>? value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+			}
+			else
+			{
+				this.Encode<#= inputType #>(value.GetValueOrDefault(), buffer);
+			}
+		}
+<#
+}
+#>
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Encoder.cs b/src/MsgPack.Abstraction/Internal/Encoder.cs
new file mode 100644
index 000000000..6ef3a7360
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Encoder.cs
@@ -0,0 +1,175 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Defines an interface and basic functionarity of stateless <see cref="Encoder"/>.
+	/// </summary>
+	/// <remarks>
+	///		The <see cref="Encoder"/> is stateless, so caller (serializer, reader, etc.) can cache the instance for performance.
+	/// </remarks>
+	public abstract partial class Encoder
+	{
+		public EncoderOptions Options { get; }
+
+		protected Encoder(EncoderOptions options)
+		{
+			this.Options = Ensure.NotNull(options);
+		}
+
+		public abstract void EncodeNull(IBufferWriter<byte> buffer);
+
+#if FEATURE_UTF8STRING
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeString(Utf8String? value, IBufferWriter<byte> buffer)
+			=> this.EncodeString(value.AsBytes(), buffer);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeString(Utf8Span value, IBufferWriter<byte> buffer)
+			=> this.EncodeString(value.AsBytes(), buffer);
+#endif // FEATURE_UTF8STRING
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeString(string? value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+				return;
+			}
+
+			this.EncodeString(value.AsSpan(), buffer, encoding, cancellationToken);
+		}
+
+		public abstract void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+		public abstract void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+		public abstract void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
+
+		public abstract void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
+
+		public abstract void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
+
+		public abstract void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
+
+		public abstract void EncodeArrayStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeArrayEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeArrayItemStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeArrayItemEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeMapStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeMapEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeMapKeyStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeMapKeyEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeMapValueStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public abstract void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
+
+		public virtual void EncodeExtension(sbyte typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
+			=> Throw.ExtensionsIsNotSupported();
+
+		public virtual void EncodeExtension(sbyte typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
+			=> Throw.ExtensionsIsNotSupported();
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void WriteRaw(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			if (value.Length <= this.Options.CancellationSupportThreshold)
+			{
+				buffer.Write(value);
+			}
+			else
+			{
+				WriteRawSlow(buffer, value, buffer.GetSpan(), cancellationToken);
+			}
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static void WriteRawSlow(IBufferWriter<byte> buffer, in ReadOnlySpan<byte> source, Span<byte> destination, CancellationToken cancellationToken)
+		{
+			// https://github.com/dotnet/runtime/blob/af1db3eccbc238745e1d163458c92c1bfa650fbd/src/libraries/System.Memory/src/System/Buffers/BuffersExtensions.cs#L133
+			ReadOnlySpan<byte> input = source;
+			while (true)
+			{
+				if (destination.IsEmpty)
+				{
+					ThrowBufferWriterReturnsEmptyBuffer(nameof(buffer));
+				}
+
+				var writeSize = Math.Min(destination.Length, input.Length);
+				input.Slice(0, writeSize).CopyTo(destination);
+				buffer.Advance(writeSize);
+				input = input.Slice(writeSize);
+				if (input.Length > 0)
+				{
+					destination = buffer.GetSpan();
+
+					cancellationToken.ThrowIfCancellationRequested();
+					continue;
+				}
+
+				return;
+			}
+		}
+
+		private static void ThrowBufferWriterReturnsEmptyBuffer(string paramName)
+			=> throw new ArgumentOutOfRangeException(paramName);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void WriteRaw(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (value.Length <= this.Options.MaxByteBufferLength)
+			{
+				var length32 = unchecked((int)value.Length);
+				var span = buffer.GetSpan(length32);
+				value.CopyTo(span);
+				buffer.Advance(length32);
+				return;
+			}
+
+			WriteRawSlow(value, buffer, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static void WriteRawSlow(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			var reader = new SequenceReader<byte>(value);
+			while (!reader.End)
+			{
+				cancellationToken.ThrowIfCancellationRequested();
+
+				var sink = buffer.GetSpan();
+				if (sink.IsEmpty)
+				{
+					ThrowBufferWriterReturnsEmptyBuffer(nameof(buffer));
+				}
+
+				var source = reader.UnreadSpan.Slice(0, Math.Min(sink.Length, reader.UnreadSpan.Length));
+				source.CopyTo(sink);
+				buffer.Advance(source.Length);
+				reader.Advance(source.Length);
+			}
+		}
+
+		private protected static IBufferWriter<byte> EnsureNotNull(IBufferWriter<byte> buffer)
+			=> buffer ?? throw new ArgumentNullException(nameof(buffer));
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/EncoderOptions.cs b/src/MsgPack.Abstraction/Internal/EncoderOptions.cs
new file mode 100644
index 000000000..8ec9bcd3b
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/EncoderOptions.cs
@@ -0,0 +1,35 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	public abstract class EncoderOptions
+	{
+		public int CancellationSupportThreshold { get; }
+
+		public int MaxByteBufferLength { get; }
+
+		public int MaxCharBufferLength { get; }
+
+		public ArrayPool<byte> ByteBufferPool { get; }
+
+		public ArrayPool<char> CharBufferPool { get; }
+
+		public bool ClearsBuffer { get; }
+
+		protected EncoderOptions(EncoderOptionsBuilder builder)
+		{
+			builder = Ensure.NotNull(builder);
+
+			this.CancellationSupportThreshold = builder.CancellationSupportThreshold;
+			this.MaxByteBufferLength = builder.MaxByteBufferLength;
+			this.MaxCharBufferLength = builder.MaxCharBufferLength;
+			this.ByteBufferPool = builder.ByteBufferPool;
+			this.CharBufferPool = builder.CharBufferPool;
+			this.ClearsBuffer = builder.ClearsBuffer;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs
new file mode 100644
index 000000000..7fa2d2ef6
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs
@@ -0,0 +1,61 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	public abstract class EncoderOptionsBuilder
+	{
+		private int _cancellationSupportThreshold = OptionsDefaults.CancellationSupportThreshold;
+
+		public int CancellationSupportThreshold
+		{
+			get => this._cancellationSupportThreshold;
+			set => this._cancellationSupportThreshold = Ensure.IsNotLessThan(value, 1);
+		}
+
+		private int _maxByteBufferLength = OptionsDefaults.MaxByteBufferLength;
+
+		public int MaxByteBufferLength
+		{
+			get => this._maxByteBufferLength;
+			set => this._maxByteBufferLength = Ensure.IsNotLessThan(value, 4);
+		}
+
+		private int _maxCharBufferLength = OptionsDefaults.MaxCharBufferLength;
+
+		public int MaxCharBufferLength
+		{
+			get => this._maxCharBufferLength;
+			set => this._maxCharBufferLength = Ensure.IsNotLessThan(value, 2);
+		}
+
+		private ArrayPool<byte> _byteBufferPool = OptionsDefaults.ByteBufferPool;
+
+		public ArrayPool<byte> ByteBufferPool
+		{
+			get => this._byteBufferPool;
+			set => this._byteBufferPool = Ensure.NotNull(value);
+		}
+
+		private ArrayPool<char> _charBufferPool = OptionsDefaults.CharBufferPool;
+
+		public ArrayPool<char> CharBufferPool
+		{
+			get => this._charBufferPool;
+			set => this._charBufferPool = Ensure.NotNull(value);
+		}
+
+		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
+
+		protected EncoderOptionsBuilder() { }
+
+		public EncoderOptionsBuilder WithoutBufferClear()
+		{
+			this.ClearsBuffer = false;
+			return this;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Ensure.cs b/src/MsgPack.Abstraction/Internal/Ensure.cs
new file mode 100644
index 000000000..3927e712f
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Ensure.cs
@@ -0,0 +1,45 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal static class Ensure
+	{
+		[return: NotNull]
+		public static T NotNull<T>([NotNull]T value, [CallerArgumentExpression("value")]string paramName = null!)
+		{
+			if (value == null)
+			{
+				throw new ArgumentNullException(paramName);
+			}
+
+			return value;
+		}
+
+		public static int IsNotNegative(int value, [CallerArgumentExpression("value")]string paramName = null!)
+		{
+			if (value < 0)
+			{
+				throw new ArgumentOutOfRangeException(paramName, "Value cannot be negative number.");
+			}
+
+			return value;
+		}
+
+		public static T IsNotLessThan<T>(T value, T minInclusive, [CallerArgumentExpression("value")] string paramName = null!)
+			where T : struct, IComparable<T>
+		{
+			if (value.CompareTo(minInclusive) < 0)
+			{
+				throw new ArgumentOutOfRangeException(paramName, $"Value cannot be less than {minInclusive}.");
+			}
+
+			return value;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
new file mode 100644
index 000000000..f20f4a578
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
@@ -0,0 +1,20 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	public sealed class FormatFeatures
+	{
+		public bool IsContextful { get; }
+		public bool CanCountCollectionItems { get; }
+		public bool CanSpecifyStringEncoding { get; }
+
+		internal FormatFeatures(FormatFeaturesBuilder builder)
+		{
+			this.IsContextful = builder.IsContextful;
+			this.CanCountCollectionItems = builder.CanCountCollectionItems;
+			this.CanSpecifyStringEncoding = builder.CanSpecifyStringEncoding;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
new file mode 100644
index 000000000..0a5d3ab2b
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
@@ -0,0 +1,15 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	public sealed class FormatFeaturesBuilder
+	{
+		public bool IsContextful { get; set; }
+		public bool CanCountCollectionItems { get; set; }
+		public bool CanSpecifyStringEncoding { get; set; }
+
+		public FormatFeatures Build() => new FormatFeatures(this);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/MethodImplOptionsShim.cs b/src/MsgPack.Abstraction/Internal/MethodImplOptionsShim.cs
new file mode 100644
index 000000000..07bf05070
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/MethodImplOptionsShim.cs
@@ -0,0 +1,22 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Defines compatibility shims for legacy runtime.
+	/// </summary>
+	internal static class MethodImplOptionsShim
+	{
+		/// <summary>
+		///		Tells JIT to inline aggressively.
+		/// </summary>
+		/// <remarks>
+		///		This value is not defined in .NET Framework 3.5, but the runtime will ignore this flag value.
+		/// </remarks>
+		public const MethodImplOptions AggressiveInlining = (MethodImplOptions)256;
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
new file mode 100644
index 000000000..c8fa9fbed
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
@@ -0,0 +1,22 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	internal static class OptionsDefaults
+	{
+		public static readonly int CancellationSupportThreshold = 128 * 1024 * 1024; // About 0.1 sec in desktop, more for IoT
+		public static readonly int MaxNumberLengthInBytes = 32;
+		public static readonly int MaxStringLengthInBytes = 256 * 1024 * 1024;
+		public static readonly int MaxBinaryLengthInBytes = 256 * 1024 * 1024;
+		public static readonly int MaxByteBufferLength = 2 * 1024 * 1024;
+		public static readonly int MaxCharBufferLength = 2 * 1024 * 1024;
+		public static readonly ArrayPool<byte> ByteBufferPool = ArrayPool<byte>.Shared;
+		public static readonly ArrayPool<char> CharBufferPool = ArrayPool<char>.Shared;
+		public static readonly bool ClearsBuffer = true;
+		public static readonly bool CanTreatRealAsInteger = true;
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
new file mode 100644
index 000000000..e320035ad
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
@@ -0,0 +1,112 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace MsgPack.Internal
+{
+	internal sealed class StreamBufferWriter : IBufferWriter<byte>, IAsyncDisposable
+	{
+		private readonly Stream _underlying;
+		private readonly bool _ownsStream;
+
+		private readonly ArrayPool<byte> _arrayPool;
+		private readonly bool _cleansBuffer;
+
+		private byte[] _buffer = null!;
+		private int _offset;
+
+		private ValueTask _flushTask;
+		private byte[]? _flushingBuffer;
+
+		public int Remaining => this._buffer.Length - this._offset;
+
+		public StreamBufferWriter(
+			Stream underlying,
+			bool ownsStream,
+			ArrayPool<byte> arrayPool,
+			bool cleansBuffer
+		)
+		{
+			this._underlying = underlying;
+			this._ownsStream = ownsStream;
+			this._arrayPool = arrayPool;
+			this._cleansBuffer = cleansBuffer;
+		}
+
+		public async ValueTask DisposeAsync()
+		{
+			await this._flushTask.ConfigureAwait(false);
+			this.CleanUpAsyncWork();
+			await this.FlushToStreamAsync().ConfigureAwait(false);
+			await this._underlying.FlushAsync().ConfigureAwait(false);
+			this._arrayPool.Return(this._buffer, this._cleansBuffer);
+			this._buffer = null!;
+			this._offset = 0;
+			if (this._ownsStream)
+			{
+				await this._underlying.DisposeAsync();
+			}
+		}
+
+		public void Advance(int count)
+			=> this._offset++;
+
+		public Memory<byte> GetMemory(int sizeHint = 0)
+		{
+			this.EnsureBuffer(sizeHint);
+			return this._buffer.AsMemory(this._offset);
+		}
+
+		public Span<byte> GetSpan(int sizeHint = 0)
+		{
+			this.EnsureBuffer(sizeHint);
+			return this._buffer.AsSpan(this._offset);
+		}
+
+		private void EnsureBuffer(int sizeHint)
+		{
+			if (this._buffer == null)
+			{
+				throw new ObjectDisposedException(this.GetType().FullName);
+			}
+
+			if (this.Remaining > 0 && this.Remaining >= sizeHint)
+			{
+				return;
+			}
+
+			if (!this._flushTask.IsCompletedSuccessfully)
+			{
+				this._flushTask.ConfigureAwait(false).GetAwaiter().GetResult();
+				this.CleanUpAsyncWork();
+			}
+
+			this._flushTask = this.FlushToStreamAsync();
+			if (!this._flushTask.IsCompletedSuccessfully)
+			{
+				this._flushingBuffer = this._buffer;
+				this._buffer = this._arrayPool.Rent(this._buffer.Length);
+			}
+
+			this._offset = 0;
+		}
+
+		private ValueTask FlushToStreamAsync()
+			=> this._underlying.WriteAsync(this._buffer.AsMemory(0, this._offset));
+
+		private void CleanUpAsyncWork()
+		{
+			if (this._flushingBuffer != null)
+			{
+				this._arrayPool.Return(this._flushingBuffer!, this._cleansBuffer);
+				this._flushingBuffer = null;
+				this._flushTask = default;
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
new file mode 100644
index 000000000..c09f44bc8
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
@@ -0,0 +1,57 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MsgPack.Internal
+{
+	internal sealed class StreamReadOnlyMemoryProvider
+	{
+		private readonly Stream _stream;
+		private readonly byte[] _buffer;
+
+		public StreamReadOnlyMemoryProvider(Stream stream, byte[] buffer)
+		{
+			this._stream = stream;
+			this._buffer = buffer;
+		}
+
+		public async ValueTask<ReadOnlyMemory<byte>> GetNextAsync(ReadOnlyMemory<byte> previous, int requestHint, CancellationToken cancellationToken)
+		{
+			var required = (long)previous.Length + requestHint;
+			if (required > UInt32.MaxValue)
+			{
+#warning TODO:
+				throw new Exception("Too large");
+			}
+
+			Memory<byte> buffer;
+			if (required < this._buffer.Length)
+			{
+				if (previous.Length > 0)
+				{
+					this._buffer.AsSpan().CopyTo(this._buffer.AsSpan(previous.Length));
+				}
+				
+				buffer = this._buffer.AsMemory(previous.Length);
+				if (requestHint > 0)
+				{
+					buffer = buffer.Slice(0, requestHint);
+				}
+			}
+			else
+			{
+				buffer = new byte[required];
+				previous.CopyTo(buffer);
+				buffer = buffer.Slice(previous.Length);
+			}
+
+			await this._stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+			return buffer;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Throw.cs b/src/MsgPack.Abstraction/Internal/Throw.cs
new file mode 100644
index 000000000..91f780428
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Throw.cs
@@ -0,0 +1,150 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Text;
+
+namespace MsgPack.Internal
+{
+	internal static class Throw
+	{
+		public static void ExtensionsIsNotSupported()
+			=> throw new NotSupportedException($"Extension type is not supported in this encoder.");
+
+		public static void TooLargeCharLength(long size)
+			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It is {size:#,0} chars, but it must be lessor than {Int32.MaxValue:#,0} chars. Use EncodeLargeString instead.");
+
+		public static void DepthExeeded(long position, int maxDepth)
+			=> throw new LimitExceededException($"The depth of collection exceeds max depth {maxDepth:#,0} at {position:#,0}.");
+
+		public static void StringLengthExceeded(long position, long length, int maxLength)
+			=> throw new LimitExceededException($"The byte length of encoded string ({length:#,0}) exceeds max length ({maxLength:#,0}) at {position:#,0}.");
+
+		public static void BinaryLengthExceeded(long position, long length, int maxLength)
+			=> throw new LimitExceededException($"The byte length of encoded binary ({length:#,0}) exceeds max length ({maxLength:#,0}) at {position:#,0}.");
+
+		public static void DepthUnderflow()
+			=> throw new InvalidOperationException("CurrentDepth is 0.");
+
+		public static void TooLargeByteLength(long size, string encodingName)
+			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to {size:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes. Use EncodeLargeString instead.");
+
+		public static void TooLargeByteLength(Exception innerException, string encodingName)
+			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to larger than {Int32.MaxValue:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes. Use EncodeLargeString instead.", innerException);
+
+		public static void TooLargeByteLengthForString(string encodingName)
+			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be decoded to larger than maximum System.String length with '{encodingName}' encoding.");
+
+		internal static void TooLargePropertyKey(long position, int length, int maxPropertyKeyLength)
+			=> throw new InvalidOperationException($"Property key is too large. The size {length:#,0} is larger than configured limit {maxPropertyKeyLength:#,0} at {position:#,0}.");
+
+		public static void InsufficientInput(long position, Type targetType, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode {targetType} value at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode {targetType} value at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForDecodeArrayOrMapHeader(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode array or map header at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode array or map header at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForDecodeArrayHeader(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode array header at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode array header at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForDecodeMapHeader(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode map header at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode map header at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForString(long position, Type type, Encoding? encoding, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode string as {type} with '{encoding}' encoding at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode string as {type} with '{encoding}' encoding at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForRawString(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to fetch raw string at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to fetch raw string at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForSkip(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to skip current subtree at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to skip current subtree at {position:#,0}.");
+			}
+		}
+
+		public static void InsufficientInputForDetectCollectionEnds(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to detect whether current collection is end at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to detect whether current collection is end at {position:#,0}.");
+			}
+		}
+
+		internal static void InsufficientInputForDrainCollectionItems(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to drain current collection items at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to current collection items at {position:#,0}.");
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Utf8EncodingNonBom.cs b/src/MsgPack.Abstraction/Internal/Utf8EncodingNonBom.cs
new file mode 100644
index 000000000..0cf4999fc
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Utf8EncodingNonBom.cs
@@ -0,0 +1,21 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Text;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Defines sealed UTF-8 class which cannot emit BOM.
+	/// </summary>
+	/// <remarks>
+	///		Sealed class typed static constant is important for JIT devirtualization optimization.
+	/// </remarks>
+	internal sealed class Utf8EncodingNonBom : UTF8Encoding
+	{
+		public static Utf8EncodingNonBom Instance { get; } = new Utf8EncodingNonBom();
+
+		private Utf8EncodingNonBom() : base(encoderShouldEmitUTF8Identifier: false) { }
+	}
+}
diff --git a/src/MsgPack.Abstraction/LimitExceededException.cs b/src/MsgPack.Abstraction/LimitExceededException.cs
new file mode 100644
index 000000000..a49484da8
--- /dev/null
+++ b/src/MsgPack.Abstraction/LimitExceededException.cs
@@ -0,0 +1,21 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack
+{
+#warning TODO: Quota? Limit?
+	public sealed class LimitExceededException : Exception
+	{
+		public LimitExceededException()
+			: this("Sime quota is exeeded.") { }
+
+		public LimitExceededException(string? message)
+			: base(message) { }
+
+		public LimitExceededException(string? message, Exception? innerException)
+			: base(message, innerException) { }
+	}
+}
diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
new file mode 100644
index 000000000..1d0ea90cf
--- /dev/null
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -0,0 +1,49 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="../MsgPack/MessageNotSupportedException.cs" Link="MessageNotSupportedException.cs" />
+    <Compile Include="../MsgPack/MessageTypeException.cs" Link="MessageTypeException.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Internal/Decoder.Strings.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Decoder.Strings.cs</LastGenOutput>
+    </None>
+    <None Update="Internal/Encoder.Primitives.tt">
+      <LastGenOutput>Encoder.Primitives.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Internal/Decoder.Primitives.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Decoder.Primitives.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Internal\Decoder.Primitives.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Decoder.Primitives.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Internal\Decoder.Strings.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Decoder.Strings.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Internal\Encoder.Primitives.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Encoder.Primitives.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  
+</Project>
diff --git a/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs b/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..4c671542f
--- /dev/null
+++ b/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs
@@ -0,0 +1,6 @@
+#warning TODO:HEADER
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("MsgPack.Core")]
+[assembly: InternalsVisibleTo("MsgPack.Json")]
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
new file mode 100644
index 000000000..7469d883d
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
@@ -0,0 +1,38 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Text;
+
+namespace MsgPack.Serialization
+{
+	public sealed class DeserializationOptions
+	{
+		public static DeserializationOptions Default { get; } = new DeserializationOptionsBuilder().Create();
+
+		public int MaxArrayLength { get; }
+		public int MaxMapCount { get; }
+		public int MaxPropertyKeyLength { get; }
+		public int MaxDepth { get; }
+		public Encoding? StringEncoding { get; }
+		public ArrayPool<byte> ArrayPool { get; }
+
+		internal DeserializationOptions(
+			int maxArrayLength,
+			int maxMapCount,
+			int maxPropertyKeyLength,
+			int maxDepth,
+			Encoding? stringEncoding,
+			ArrayPool<byte> arrayPool
+		)
+		{
+			this.MaxArrayLength =maxArrayLength;
+			this.MaxMapCount = maxMapCount;
+			this.MaxPropertyKeyLength = maxPropertyKeyLength;
+			this.MaxDepth = maxDepth;
+			this.StringEncoding = stringEncoding;
+			this.ArrayPool = arrayPool;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
new file mode 100644
index 000000000..54dab8ca0
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
@@ -0,0 +1,58 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+#warning TODO: tuning default as backward compatible
+	public sealed class DeserializationOptionsBuilder
+	{
+		internal const int DefaultMaxArrayLength = 1024 * 1024;
+		internal const int DefaultMaxMapCount = 1024 * 1024;
+		internal const int DefaultMaxPropertyKeyLength = 256;
+		internal const int DefaultMaxDepth = 100;
+
+		private int _maxArrayLength = DefaultMaxArrayLength;
+
+		public int MaxArrayLength
+		{
+			get => this._maxArrayLength;
+			set => this._maxArrayLength = Ensure.IsNotLessThan(value, 0);
+		}
+
+		private int _maxMapCount = DefaultMaxMapCount;
+
+		public int MaxMapCount
+		{
+			get => this._maxMapCount;
+			set => this._maxMapCount = Ensure.IsNotLessThan(value, 0);
+		}
+
+		private int _maxPropertyKeyLength = DefaultMaxPropertyKeyLength;
+
+		public int MaxPropertyKeyLength
+		{
+			get => this._maxPropertyKeyLength;
+			set => this._maxPropertyKeyLength = Ensure.IsNotLessThan(value, 1);
+		}
+
+		private int _maxDepth = DefaultMaxDepth;
+
+		public int MaxDepth
+		{
+			get => this._maxDepth;
+			set => this._maxDepth = Ensure.IsNotLessThan(value, 1);
+		}
+
+		public Encoding? StringEncoding { get; set; }
+
+		public ArrayPool<byte>? ArrayPool { get; set; }
+
+		public DeserializationOptions Create()
+			=> new DeserializationOptions(this.MaxArrayLength, this.MaxMapCount, this.MaxPropertyKeyLength, this.MaxDepth, this.StringEncoding, this.ArrayPool ?? ArrayPool<byte>.Shared);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs
new file mode 100644
index 000000000..2c267e72f
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs
@@ -0,0 +1,65 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	public struct DeserializationOperationContext
+	{
+		public Decoder Decoder { get; }
+		public DeserializationOptions Options { get; }
+		public int CurrentDepth { get; private set; }
+		public CancellationToken CancellationToken { get; }
+		public ArrayPool<byte> ArrayPool => this.Options.ArrayPool;
+		public System.Text.Encoding? StringEncoding => this.Options.StringEncoding;
+
+		public DeserializationOperationContext(Decoder decoder, DeserializationOptions? options, CancellationToken cancellationToken)
+		{
+			this.Decoder = Ensure.NotNull(decoder);
+			this.Options = options ?? DeserializationOptions.Default;
+			this.CurrentDepth = 0;
+			this.CancellationToken = cancellationToken;
+		}
+
+		public CollectionContext CollectionContext =>
+			new CollectionContext(
+				this.Options.MaxArrayLength, 
+				this.Options.MaxMapCount,
+				this.Options.MaxDepth, 
+				this.CurrentDepth
+			);
+
+		public int IncrementDepth()
+		{
+			if (this.CurrentDepth == this.Options.MaxDepth)
+			{
+				Throw.DepthExeeded(this.CurrentDepth, this.Options.MaxDepth);
+			}
+
+			return this.CurrentDepth++;
+		}
+
+		public int DecrementDepth()
+		{
+			if (this.CurrentDepth == 0)
+			{
+				Throw.DepthUnderflow();
+			}
+
+			return this.CurrentDepth--;
+		}
+
+		public readonly void ValidatePropertyKeyLength(long position, int length)
+		{
+			if(length > this.Options.MaxPropertyKeyLength)
+			{
+				Throw.TooLargePropertyKey(position, length, this.Options.MaxPropertyKeyLength);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs
new file mode 100644
index 000000000..7f267b7db
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs
@@ -0,0 +1,20 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace MsgPack.Serialization.Internal
+{
+	public interface IObjectSerializer<T>
+	{
+		void Serialize(in SerializationOperationContext context, T obj, IBufferWriter<byte> sink);
+		ValueTask SerializeAsync(SerializationOperationContext context, T obj, Stream streamSink);
+		T Deserialize(in DeserializationOperationContext context, in SequenceReader<byte> source);
+		ValueTask<T> DeserializeAsync(DeserializationOperationContext context, Stream streamSource);
+		void DeserializeTo(in DeserializationOperationContext context, in SequenceReader<byte> source, in T obj);
+		ValueTask DeserializeToAsync(DeserializationOperationContext context, Stream streamSource, T obj);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs
new file mode 100644
index 000000000..689a70b57
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs
@@ -0,0 +1,50 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	public struct SerializationOperationContext
+	{
+		public Encoder Encoder { get; }
+		public SerializationOptions Options { get; }
+		private int _currentDepth;
+		public int CurrentDepth => this._currentDepth;
+		public CancellationToken CancellationToken { get; }
+		public System.Text.Encoding? StringEncoding => this.Options.StringEncoding;
+
+		public SerializationOperationContext(Encoder encoder, SerializationOptions? options, CancellationToken cancellationToken)
+		{
+			this.Encoder = Ensure.NotNull(encoder);
+			this.Options = options ?? SerializationOptions.Default;
+			this._currentDepth = 0;
+			this.CancellationToken = cancellationToken;
+		}
+
+		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this._currentDepth);
+
+		public int IncrementDepth()
+		{
+			if (this._currentDepth == this.Options.MaxDepth)
+			{
+				Throw.DepthExeeded(this._currentDepth, this.Options.MaxDepth);
+			}
+
+			return this._currentDepth++;
+		}
+
+		public int DecrementDepth()
+		{
+			if (this._currentDepth == 0)
+			{
+				Throw.DepthUnderflow();
+			}
+
+			return this._currentDepth--;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
new file mode 100644
index 000000000..0b9d8d13d
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
@@ -0,0 +1,26 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Text;
+
+namespace MsgPack.Serialization
+{
+	public sealed class SerializationOptions
+	{
+		public static SerializationOptions Default { get; } = new SerializationOptionsBuilder().Create();
+
+		public int MaxDepth { get; }
+
+		public Encoding? StringEncoding { get; }
+
+		internal SerializationOptions(
+			int maxDepth,
+			Encoding? stringEncoding
+		)
+		{
+			this.MaxDepth = maxDepth;
+			this.StringEncoding = stringEncoding;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
new file mode 100644
index 000000000..8016eeece
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
@@ -0,0 +1,24 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	public sealed class SerializationOptionsBuilder
+	{
+		private int _maxDepth;
+
+		public int MaxDepth
+		{
+			get => this._maxDepth;
+			set => this._maxDepth = Ensure.IsNotLessThan(value, 1);
+		}
+
+		public System.Text.Encoding? StringEncoding { get; set; }
+
+		public SerializationOptions Create()
+			=> new SerializationOptions(this.MaxDepth, this.StringEncoding);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer`1.cs b/src/MsgPack.Abstraction/Serialization/Serializer`1.cs
new file mode 100644
index 000000000..bb959aee2
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Serializer`1.cs
@@ -0,0 +1,112 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+using MsgPack.Serialization.Internal;
+
+namespace MsgPack.Serialization
+{
+	public abstract class Serializer<T>
+	{
+		private readonly Func<Encoder> _encoderFactory;
+		private readonly Func<Decoder> _decoderFactory;
+		private readonly IObjectSerializer<T> _underlying;
+		private readonly SerializationOptions _serializationOptions;
+		private readonly DeserializationOptions _deserializationOptions;
+
+		protected Serializer(
+			Func<Encoder> encoderFactory,
+			Func<Decoder> decoderFactory,
+			IObjectSerializer<T> underlying,
+			SerializationOptions serializationOptions,
+			DeserializationOptions deserializationOptions
+		)
+		{
+			this._encoderFactory = Ensure.NotNull(encoderFactory);
+			this._decoderFactory = Ensure.NotNull(decoderFactory);
+			this._underlying = Ensure.NotNull(underlying);
+			this._serializationOptions = Ensure.NotNull(serializationOptions);
+			this._deserializationOptions = Ensure.NotNull(deserializationOptions);
+		}
+
+		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext context)
+			=> context = new SerializationOperationContext(this._encoderFactory(), this._serializationOptions, cancellationToken);
+
+		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext context)
+			=> context = new DeserializationOperationContext(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+
+		public void Serialize(T obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default)
+		{
+			this.InitializeSerializationOperationContext(cancellationToken, out var context);
+			this._underlying.Serialize(context, obj, sink);
+		}
+
+		public ReadOnlyMemory<byte> Serialize(T obj, CancellationToken cancellationToken = default)
+		{
+			this.InitializeSerializationOperationContext(cancellationToken, out var context);
+			var writer = new ArrayBufferWriter<byte>();
+			this._underlying.Serialize(context, obj, writer);
+			return writer.WrittenMemory;
+		}
+
+		public ValueTask SerializeAsync(T obj, Stream streamSink, CancellationToken cancellationToken = default)
+		{
+			this.InitializeSerializationOperationContext(cancellationToken, out var context);
+			return this._underlying.SerializeAsync(context, obj, streamSink);
+		}
+
+		public T Deserialize(in SequenceReader<byte> reader, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			return this._underlying.Deserialize(context, reader);
+		}
+
+		public T Deserialize(in ReadOnlySequence<byte> source, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			return this._underlying.Deserialize(context, new SequenceReader<byte>(source));
+		}
+
+		public T Deserialize(ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			return this._underlying.Deserialize(context, new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource)));
+		}
+
+		public ValueTask<T> DeserializeAsync(Stream streamSource, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			return this._underlying.DeserializeAsync(context, streamSource);
+		}
+
+		public void DeserializeTo(in SequenceReader<byte> reader, T obj, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			this._underlying.DeserializeTo(context, reader, obj);
+		}
+
+		public void DeserializeTo(in ReadOnlySequence<byte> source, T obj, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			this._underlying.DeserializeTo(context, new SequenceReader<byte>(source), obj);
+		}
+
+		public void DeserializeTo(ReadOnlyMemory<byte> memorySource, T obj, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			this._underlying.DeserializeTo(context, new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource)), obj);
+		}
+
+		public ValueTask DeserializeToAsync(Stream streamSource, T obj, CancellationToken cancellationToken = default)
+		{
+			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			return this._underlying.DeserializeToAsync(context, streamSource, obj);
+		}
+	}
+}
diff --git a/src/MsgPack.Compatibility/MsgPack.Compatibility.csproj b/src/MsgPack.Compatibility/MsgPack.Compatibility.csproj
new file mode 100644
index 000000000..cb6319069
--- /dev/null
+++ b/src/MsgPack.Compatibility/MsgPack.Compatibility.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
new file mode 100644
index 000000000..46a753c2a
--- /dev/null
+++ b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
@@ -0,0 +1,163 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		MessagePack encoder.
+	/// </summary>
+	internal sealed class CurrentMessagePackEncoder : MessagePackEncoder
+	{
+		public CurrentMessagePackEncoder(MessagePackEncoderOptions options)
+			: base(options) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected sealed override int EncodeStringHeader(uint length, Span<byte> buffer)
+		{
+			if (length < 32)
+			{
+				buffer[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | length));
+				return 1;
+			}
+			else if (length <= Byte.MaxValue)
+			{
+				buffer[1] = unchecked((byte)length);
+				buffer[0] = MessagePackCode.Str8;
+				return 2;
+			}
+			else if (length <= UInt16.MaxValue)
+			{
+				buffer[0] = MessagePackCode.Str16;
+				BinaryPrimitives.WriteUInt16BigEndian(buffer, unchecked((ushort)length));
+				return sizeof(ushort) + 1;
+			}
+			else
+			{
+				buffer[0] = MessagePackCode.Str32;
+				BinaryPrimitives.WriteUInt32BigEndian(buffer, length);
+				return sizeof(uint) + 1;
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected sealed override int EncodeBinaryHeader(uint length, Span<byte> buffer)
+		{
+			if (length <= Byte.MaxValue)
+			{
+				buffer[1] = unchecked((byte)length);
+				buffer[0] = MessagePackCode.Bin8;
+				return 2;
+			}
+			else if (length <= UInt16.MaxValue)
+			{
+				buffer[0] = MessagePackCode.Bin16;
+				BinaryPrimitives.WriteUInt16BigEndian(buffer, unchecked((ushort)length));
+				return sizeof(ushort) + 1;
+			}
+			else
+			{
+				buffer[0] = MessagePackCode.Bin32;
+				BinaryPrimitives.WriteUInt32BigEndian(buffer, length);
+				return sizeof(uint) + 1;
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeExtension(sbyte typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
+		{
+			EncodeExtensionHeader(typeCode, unchecked((uint)serializedValue.Length), buffer);
+			buffer.Write(serializedValue);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeExtension(sbyte typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
+		{
+			EncodeExtensionHeader(typeCode, unchecked((uint)serializedValue.Length), buffer);
+			this.WriteRaw(serializedValue, buffer);
+		}
+
+		private static void EncodeExtensionHeader(sbyte typeCode, uint serializedValueLength, IBufferWriter<byte> buffer)
+		{
+			switch (serializedValueLength)
+			{
+				case 1:
+				{
+					var span = buffer.GetSpan(1);
+					span[0] = MessagePackCode.FixExt1;
+					buffer.Advance(1);
+					break;
+				}
+				case 2:
+				{
+					var span = buffer.GetSpan(1);
+					span[0] = MessagePackCode.FixExt2;
+					buffer.Advance(1);
+					break;
+				}
+				case 4:
+				{
+					var span = buffer.GetSpan(1);
+					span[0] = MessagePackCode.FixExt4;
+					buffer.Advance(1);
+					break;
+				}
+				case 8:
+				{
+					var span = buffer.GetSpan(1);
+					span[0] = MessagePackCode.FixExt8;
+					buffer.Advance(1);
+					break;
+				}
+				case 16:
+				{
+					var span = buffer.GetSpan(1);
+					span[0] = MessagePackCode.FixExt16;
+					buffer.Advance(1);
+					break;
+				}
+				default:
+				{
+					if (serializedValueLength <= Byte.MaxValue)
+					{
+						var span = buffer.GetSpan(2);
+						span[0] = MessagePackCode.Ext8;
+						span[1] = unchecked((byte)serializedValueLength);
+						buffer.Advance(2);
+					}
+					else if (serializedValueLength <= UInt16.MaxValue)
+					{
+						var span = buffer.GetSpan(sizeof(ushort) + 1);
+						span[0] = MessagePackCode.Ext16;
+						span = span.Slice(1);
+						BinaryPrimitives.WriteUInt16BigEndian(span, unchecked((ushort)serializedValueLength));
+						buffer.Advance(sizeof(ushort) + 1);
+					}
+					else
+					{
+						var span = buffer.GetSpan(sizeof(uint) + 1);
+						span[0] = MessagePackCode.Ext32;
+						span = span.Slice(1);
+						BinaryPrimitives.WriteUInt32BigEndian(span, serializedValueLength);
+						buffer.Advance(sizeof(uint) + 1);
+					}
+
+					break;
+				}
+			} // switch
+
+			// type code
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)typeCode);
+				buffer.Advance(1);
+			}
+		}
+
+	}
+}
diff --git a/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs b/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs
new file mode 100644
index 000000000..f0d39367e
--- /dev/null
+++ b/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs
@@ -0,0 +1,45 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		MessagePack encoder for legacy format which uses raw type instead of str type and does not support ext type.
+	/// </summary>
+	internal sealed class LegacyMessagePackEncoder : MessagePackEncoder
+	{
+		public LegacyMessagePackEncoder(MessagePackEncoderOptions options)
+			: base(options) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected sealed override int EncodeStringHeader(uint length, Span<byte> buffer)
+		{
+			if (length < 32)
+			{
+				buffer[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | length));
+				return 1;
+			}
+			else if (length <= UInt16.MaxValue)
+			{
+				buffer[0] = MessagePackCode.Raw16;
+				BinaryPrimitives.WriteUInt16BigEndian(buffer, unchecked((ushort)length));
+				return sizeof(ushort) + 1;
+			}
+			else
+			{
+				buffer[0] = MessagePackCode.Raw32;
+				BinaryPrimitives.WriteUInt32BigEndian(buffer, length);
+				return sizeof(uint) + 1;
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected sealed override int EncodeBinaryHeader(uint length, Span<byte> buffer)
+			=> this.EncodeStringHeader(length, buffer);
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MemoryExtensions.cs b/src/MsgPack.Core/Internal/MemoryExtensions.cs
new file mode 100644
index 000000000..02c2e72dc
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MemoryExtensions.cs
@@ -0,0 +1,34 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal static class MemoryExtensions
+	{
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static void Convert(this System.Text.Encoder encoder, ReadOnlyMemory<char> source, Memory<byte> sink, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
+			=> encoder.Convert(source.Span, sink.Span, flush, out charsUsed, out bytesUsed, out completed);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static unsafe Memory<T> Compact<T>(this Memory<T> memory, T[] array, int used)
+			where T : unmanaged
+		{
+			var span = memory.Span.Slice(used);
+			if (span.IsEmpty)
+			{
+				return array;
+			}
+
+			fixed (T* pSrc = span)
+			fixed (T* pDest = array)
+			{
+				Buffer.MemoryCopy(pSrc, pDest, array.Length, span.Length);
+				return array.AsMemory(0, span.Length);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
new file mode 100644
index 000000000..5f8d6ca3f
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
@@ -0,0 +1,171 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	public partial class MessagePackDecoder
+	{
+		public sealed override CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount, out int requestHint)
+		{
+			var consumed = 0L;
+			var result = this.PrivateDecodeArrayOrMapHeader(source, ref consumed, out var header, out itemsCount, out requestHint);
+
+			if (itemsCount > Int32.MaxValue)
+			{
+				MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - consumed, itemsCount);
+			}
+
+			return result;
+		}
+
+		private CollectionType PrivateDecodeArrayOrMapHeader(in SequenceReader<byte> source, ref long consumed, out byte header, out long itemsCount, out int requestHint)
+		{
+			var result = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out header, out itemsCount, out requestHint);
+			if (result == CollectionType.None)
+			{
+				MessagePackThrow.TypeIsNotArrayNorMap(header, source.Consumed - consumed);
+			}
+
+			return result;
+		}
+
+		private CollectionType DecodeArrayOrMapHeaderCore(in SequenceReader<byte> source, ref long consumed, out byte header, out long itemsCount, out int requestHint)
+		{
+			if (!this.TryPeek(source, out header))
+			{
+				requestHint = 1;
+				itemsCount = 0;
+				return default;
+			}
+
+			if ((header & MessagePackCode.MinimumFixedArray) == MessagePackCode.MinimumFixedArray)
+			{
+				itemsCount = (uint)header - MessagePackCode.MinimumFixedArray;
+				requestHint = 0;
+				source.Advance(1);
+				consumed++;
+				return CollectionType.Array;
+			}
+
+			if ((header & MessagePackCode.MaximumFixedMap) == MessagePackCode.MaximumFixedMap)
+			{
+				itemsCount = (uint)header - MessagePackCode.MaximumFixedMap;
+				requestHint = 0;
+				source.Advance(1);
+				consumed++;
+				return CollectionType.Map;
+			}
+
+			int length;
+			CollectionType type;
+			switch (header)
+			{
+				case MessagePackCode.Array16:
+				{
+					length = 3;
+					type = CollectionType.Array;
+					break;
+				}
+				case MessagePackCode.Array32:
+				{
+					length = 5;
+					type = CollectionType.Array;
+					break;
+				}
+				case MessagePackCode.Map16:
+				{
+					length = 3;
+					type = CollectionType.Map;
+					break;
+				}
+				case MessagePackCode.Map32:
+				{
+					length = 5;
+					type = CollectionType.Map;
+					break;
+				}
+				default:
+				{
+					requestHint = 0;
+					itemsCount = 0;
+					return default;
+				}
+			}
+
+			var lengthOfLength = length - 1;
+
+			switch (lengthOfLength)
+			{
+				case 2:
+				{
+					itemsCount = ReadValue<ushort>(source, offset: 1, out requestHint);
+					break;
+				}
+				default: // 4
+				{
+					itemsCount = ReadValue<uint>(source, offset: 1, out requestHint);
+					break;
+				}
+			}
+
+			if (requestHint != 0)
+			{
+				return CollectionType.None;
+			}
+
+			source.Advance(length);
+			consumed += length;
+			return type;
+		}
+
+		public sealed override long DecodeArrayHeader(in SequenceReader<byte> source, out int requestHint)
+		{
+			var consumed = 0L;
+			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var itemsCount, out requestHint);
+			if (requestHint != 0)
+			{
+				source.Rewind(consumed);
+				return 0;
+			}
+
+			if (itemsCount > Int32.MaxValue)
+			{
+				MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - consumed, itemsCount);
+			}
+
+			if (!type.IsArray)
+			{
+				MessagePackThrow.TypeIsNotArray(header, source.Consumed - consumed);
+			}
+
+			return (int)itemsCount;
+		}
+
+		public sealed override long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint)
+		{
+			var consumed = 0L;
+			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var itemsCount, out requestHint);
+			if (requestHint != 0)
+			{
+				source.Rewind(consumed);
+				return 0;
+			}
+
+			if (itemsCount > Int32.MaxValue)
+			{
+				MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - consumed, itemsCount);
+			}
+
+			if (!type.IsMap)
+			{
+				MessagePackThrow.TypeIsNotMap(header, source.Consumed - consumed);
+			}
+
+			return (int)itemsCount;
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
new file mode 100644
index 000000000..d3e8190ca
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
@@ -0,0 +1,355 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	public partial class MessagePackDecoder
+	{
+		public sealed override ElementType DecodeItem(in SequenceReader<byte> source, out ReadOnlySequence<byte> valueOrLength, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var elementType = this.ReadHeader(source, out var consumed, out var valueOrLengthScalar, out var requestHint32);
+			if (requestHint32 != 0)
+			{
+				requestHint = requestHint32;
+				valueOrLength = default;
+				return ElementType.Null;
+			}
+
+			requestHint = 0;
+
+			switch (elementType)
+			{
+				case ElementType.True:
+				case ElementType.False:
+				case ElementType.Null:
+				{
+					valueOrLength = default;
+					break;
+				}
+				case ElementType.Int32:
+				case ElementType.Single:
+				{
+					var buffer = new byte[sizeof(int)];
+					var span = MemoryMarshal.Cast<byte, int>(buffer);
+					span[0] = (int)valueOrLengthScalar;
+					valueOrLength = new ReadOnlySequence<byte>(buffer);
+					break;
+				}
+				case ElementType.Array:
+				case ElementType.Map:
+				case ElementType.Int64:
+				case ElementType.UInt64:
+				case ElementType.Double:
+				{
+					var buffer = new byte[sizeof(long)];
+					var span = MemoryMarshal.Cast<byte, long>(buffer);
+					span[0] = valueOrLengthScalar;
+					valueOrLength = new ReadOnlySequence<byte>(buffer);
+					break;
+				}
+				case ElementType.String:
+				case ElementType.Binary:
+				{
+					if (source.Remaining < valueOrLengthScalar + consumed)
+					{
+						requestHint = (int)((valueOrLengthScalar + consumed - source.Remaining) & Int32.MaxValue);
+						valueOrLength = default;
+						return default;
+					}
+
+					valueOrLength = source.Sequence.Slice(source.Consumed + consumed, valueOrLengthScalar);
+					consumed += valueOrLengthScalar;
+					break;
+				}
+				default:
+				{
+					Debug.Assert(elementType == ElementType.Extension, $"elementType({elementType}, 0x{elementType:X8}) == ElementType.Extension");
+
+					if(source.Remaining < valueOrLengthScalar + consumed)
+					{
+						requestHint = (int)((valueOrLengthScalar + consumed - source.Remaining) & Int32.MaxValue);
+						valueOrLength = default;
+						return default;
+					}
+
+					valueOrLength = source.Sequence.Slice(source.Consumed + consumed, valueOrLengthScalar + 1 /* typeCode */);
+					consumed += valueOrLengthScalar;
+					break;
+				}
+			}
+
+			source.Advance(consumed);
+			return elementType;
+		}
+
+		private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed, out long valueOrLength, out int requestHint)
+		{
+			if (!this.TryPeek(source, out var header))
+			{
+				requestHint = 1;
+				valueOrLength = default;
+				consumed = 0;
+				return default;
+			}
+
+			consumed = 1;
+			ElementType result;
+			requestHint = 0;
+
+			if (header < 128)
+			{
+				valueOrLength = header;
+				result = ElementType.Int32;
+			}
+			else if (header >= 0xE0)
+			{
+				valueOrLength = unchecked((sbyte)header);
+				result = ElementType.Int32;
+			}
+			else if (header >= MessagePackCode.MinimumFixedRaw && header <= MessagePackCode.MaximumFixedRaw)
+			{
+				valueOrLength = header - MessagePackCode.MinimumFixedRaw;
+				result = ElementType.String;
+			}
+			else if (header >= MessagePackCode.MinimumFixedArray && header <= MessagePackCode.MaximumFixedArray)
+			{
+				valueOrLength = header - MessagePackCode.MinimumFixedArray;
+				result = ElementType.Array;
+			}
+			else if (header >= MessagePackCode.MinimumFixedMap && header <= MessagePackCode.MaximumFixedMap)
+			{
+				valueOrLength = header - MessagePackCode.MinimumFixedMap;
+				result = ElementType.Map;
+			}
+			else
+			{
+				switch (header)
+				{
+					case MessagePackCode.SignedInt8:
+					{
+						valueOrLength = ReadSByte(source, offset: 1, out requestHint);
+						consumed += sizeof(sbyte);
+						result = ElementType.Int32;
+						break;
+					}
+					case MessagePackCode.SignedInt16:
+					{
+						valueOrLength = ReadValue<short>(source, offset: 1, out requestHint);
+						consumed += sizeof(short);
+						result = ElementType.Int32;
+						break;
+					}
+					case MessagePackCode.SignedInt32:
+					{
+						valueOrLength = ReadValue<int>(source, offset: 1, out requestHint);
+						consumed += sizeof(int);
+						result = ElementType.Int32;
+						break;
+					}
+					case MessagePackCode.SignedInt64:
+					{
+						valueOrLength = ReadValue<long>(source, offset: 1, out requestHint);
+						consumed += sizeof(long);
+						result = ElementType.Int64;
+						break;
+					}
+					case MessagePackCode.UnsignedInt8:
+					{
+						valueOrLength = ReadByte(source, offset: 1, out requestHint);
+						consumed += sizeof(byte);
+						result = ElementType.Int32;
+						break;
+					}
+					case MessagePackCode.UnsignedInt16:
+					{
+						valueOrLength = ReadValue<ushort>(source, offset: 1, out requestHint);
+						consumed += sizeof(ushort);
+						result = ElementType.Int32;
+						break;
+					}
+					case MessagePackCode.UnsignedInt32:
+					{
+						valueOrLength = ReadValue<uint>(source, offset: 1, out requestHint);
+						consumed += sizeof(uint);
+						result = ElementType.Int64;
+						break;
+					}
+					case MessagePackCode.UnsignedInt64:
+					{
+						valueOrLength = unchecked((long)ReadValue<ulong>(source, offset: 1, out requestHint));
+						consumed += sizeof(ulong);
+						result = ElementType.UInt64;
+						break;
+					}
+					case MessagePackCode.Real32:
+					{
+						valueOrLength = ReadValue<int>(source, offset: 1, out requestHint);
+						consumed += sizeof(int);
+						result = ElementType.Single;
+						break;
+					}
+					case MessagePackCode.Real64:
+					{
+						valueOrLength = ReadValue<long>(source, offset: 1, out requestHint);
+						consumed += sizeof(long);
+						result = ElementType.Double;
+						break;
+					}
+					case MessagePackCode.NilValue:
+					{
+						valueOrLength = 0;
+						result = ElementType.Null;
+						break;
+					}
+					case MessagePackCode.TrueValue:
+					{
+						valueOrLength = 1;
+						result = ElementType.True;
+						break;
+					}
+					case MessagePackCode.FalseValue:
+					{
+						valueOrLength = 0;
+						result = ElementType.False;
+						break;
+					}
+					case MessagePackCode.Array16:
+					{
+						valueOrLength = ReadValue<ushort>(source, offset: 1, out requestHint);
+						consumed += sizeof(ushort);
+						result = ElementType.Array;
+						break;
+					}
+					case MessagePackCode.Array32:
+					{
+						valueOrLength = ReadValue<uint>(source, offset: 1, out requestHint);
+						consumed += sizeof(uint);
+						result = ElementType.Array;
+						break;
+					}
+					case MessagePackCode.Map16:
+					{
+						valueOrLength = ReadValue<ushort>(source, offset: 1, out requestHint);
+						consumed += sizeof(ushort);
+						result = ElementType.Map;
+						break;
+					}
+					case MessagePackCode.Map32:
+					{
+						valueOrLength = ReadValue<uint>(source, offset: 1, out requestHint);
+						consumed += sizeof(uint);
+						result = ElementType.Map;
+						break;
+					}
+					case MessagePackCode.FixExt1:
+					case MessagePackCode.FixExt2:
+					case MessagePackCode.FixExt4:
+					case MessagePackCode.FixExt8:
+					case MessagePackCode.FixExt16:
+					case MessagePackCode.Ext8:
+					case MessagePackCode.Ext16:
+					case MessagePackCode.Ext32:
+					{
+						result = ReadExtentionItem(header, source, offset: 1, ref consumed, out valueOrLength, out requestHint);
+						break;
+					}
+					default:
+					{
+						Debug.Assert(header == 0xC1, $"header(0x{header:X2}) == 0xC1");
+						valueOrLength = 0;
+						result = ElementType.None;
+						break;
+					}
+				} // switch
+			} // else
+
+			return result;
+		}
+
+		private static ElementType ReadExtentionItem(byte header, SequenceReader<byte> source, int offset, ref long consumed, out long valueOrLength, out int requestHint)
+		{
+			consumed++;
+			requestHint = 0;
+
+			switch (header)
+			{
+				case MessagePackCode.FixExt1:
+				{
+					valueOrLength = 1;
+					break;
+				}
+				case MessagePackCode.FixExt2:
+				{
+					valueOrLength = 2;
+					break;
+				}
+				case MessagePackCode.FixExt4:
+				{
+					valueOrLength = 4;
+					break;
+				}
+				case MessagePackCode.FixExt8:
+				{
+					valueOrLength = 8;
+					break;
+				}
+				case MessagePackCode.FixExt16:
+				{
+					valueOrLength = 16;
+					break;
+				}
+				default:
+				{
+					_ = ReadByte(source, offset, out requestHint);
+					if (requestHint != 0)
+					{
+						valueOrLength = default;
+						return default;
+					}
+
+					consumed++;
+					offset++;
+
+					switch (header)
+					{
+						case MessagePackCode.Ext8:
+						{
+							valueOrLength = ReadByte(source, offset, out requestHint);
+							consumed++;
+							break;
+						}
+						case MessagePackCode.Ext16:
+						{
+							valueOrLength = ReadValue<ushort>(source, offset, out requestHint);
+							consumed += sizeof(ushort);
+							break;
+						}
+						default:
+						{
+							Debug.Assert(header == MessagePackCode.Ext32, $"header(0x{header:X2}) == MessagePackCode.Ext32(0x{MessagePackCode.Ext32:X2})");
+							valueOrLength = ReadValue<uint>(source, offset + 1, out requestHint);
+							consumed += sizeof(uint);
+							break;
+						}
+					}
+
+					break;
+				}
+			}
+
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			return ElementType.Extension;
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
new file mode 100644
index 000000000..6523729bd
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
@@ -0,0 +1,138 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	public partial class MessagePackDecoder
+	{
+		private uint ReadExtensionHeader(in SequenceReader<byte> source, out int consumed, out int requestHint)
+		{
+			if(!this.TryPeek(source, out var header))
+			{
+				consumed = 0;
+				requestHint = 1;
+				return default;
+			}
+
+			consumed = 1;
+
+			int lengthOflength;
+			switch (header)
+			{
+				case MessagePackCode.FixExt1:
+				{
+					requestHint = 0;
+					return 1;
+				}
+				case MessagePackCode.FixExt2:
+				{
+					requestHint = 0;
+					return 2;
+				}
+				case MessagePackCode.FixExt4:
+				{
+					requestHint = 0;
+					return 4;
+				}
+				case MessagePackCode.FixExt8:
+				{
+					requestHint = 0;
+					return 8;
+				}
+				case MessagePackCode.FixExt16:
+				{
+					requestHint = 0;
+					return 16;
+				}
+				case MessagePackCode.Ext8:
+				{
+					lengthOflength = 1;
+					break;
+				}
+				case MessagePackCode.Ext16:
+				{
+					lengthOflength = 2;
+					break;
+				}
+				case MessagePackCode.Ext32:
+				{
+					lengthOflength = 4;
+					break;
+				}
+				default:
+				{
+					MessagePackThrow.IsNotExtension(header, source.Consumed);
+					// never
+					requestHint = default;
+					return default;
+				}
+			} // switch
+
+			uint length;
+			switch (lengthOflength)
+			{
+				case 1:
+				{
+					length = ReadByte(source, offset: 1, out requestHint);
+					break;
+				}
+				case 2:
+				{
+					length = ReadValue<ushort>(source, offset: 1, out requestHint);
+					break;
+				}
+				default:
+				{
+					Debug.Assert(lengthOflength == 4, $"length({lengthOflength}) == 4");
+					length = ReadValue<uint>(source, offset: 1, out requestHint);
+					break;
+				}
+			}
+
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			consumed += lengthOflength;
+			return length;
+		}
+
+		public override void DecodeExtension(in SequenceReader<byte> source, out byte typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var bodyLength = this.ReadExtensionHeader(source, out var consumed, out requestHint);
+			if (requestHint != 0)
+			{
+				typeCode = default;
+				body = default;
+				return;
+			}
+
+			if (!this.TryPeek(source, out typeCode))
+			{
+				requestHint = 1;
+				body = default;
+				return;
+			}
+
+			consumed++;
+
+			if (source.Remaining < consumed + bodyLength)
+			{
+				requestHint = (int)((consumed + bodyLength - (int)source.Remaining) & Int32.MaxValue);
+				body = default;
+				return;
+			}
+
+			requestHint = 0;
+			body = source.Sequence.Slice(consumed, bodyLength);
+			source.Advance(consumed + bodyLength);
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs
new file mode 100644
index 000000000..1708f0b05
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs
@@ -0,0 +1,449 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackDecoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override SByte DecodeSByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeSignedInteger(source, typeof(SByte), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			if (result < SByte.MinValue || result > SByte.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(SByte));
+			}
+
+			return unchecked((SByte)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int16 DecodeInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeSignedInteger(source, typeof(Int16), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			if (result < Int16.MinValue || result > Int16.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(Int16));
+			}
+
+			return unchecked((Int16)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int32 DecodeInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeSignedInteger(source, typeof(Int32), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			if (result < Int32.MinValue || result > Int32.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(Int32));
+			}
+
+			return unchecked((Int32)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int64 DecodeInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeSignedInteger(source, typeof(Int64), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			return unchecked((Int64)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Byte DecodeByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeUnsignedInteger(source, typeof(Byte), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			if (result < Byte.MinValue || result > Byte.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(Byte));
+			}
+
+			return unchecked((Byte)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt16 DecodeUInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeUnsignedInteger(source, typeof(UInt16), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			if (result < UInt16.MinValue || result > UInt16.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(UInt16));
+			}
+
+			return unchecked((UInt16)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt32 DecodeUInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeUnsignedInteger(source, typeof(UInt32), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			if (result < UInt32.MinValue || result > UInt32.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(UInt32));
+			}
+
+			return unchecked((UInt32)result);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt64 DecodeUInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryDecodeUnsignedInteger(source, typeof(UInt64), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+			return unchecked((UInt64)result);
+		}
+
+
+		private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, out byte header, out Int64 value, out int requestHint)
+		{
+			if (!this.TryPeek(source, out header))
+			{
+				requestHint = 1;
+				value = default;
+				return false;
+			}
+
+			requestHint = 0;
+
+			if (header < 128)
+			{
+				value = header;
+				return true;
+			}
+
+			if (header >= 0xE0)
+			{
+				value = unchecked((sbyte)header);
+				return true;
+			}
+
+			ParseNumberHeader(header, source, type, out var length, out var kind);
+
+			if ((kind & NumberKind.RealBitMask) != 0 && !this.Options.CanTreatRealAsInteger)
+			{
+				MessagePackThrow.RealCannotBeInteger(header, source.Consumed, type);
+			}
+
+			switch (kind)
+			{
+				case NumberKind.Signed:
+				{
+					switch (length)
+					{
+						case 1:
+						{
+							value = ReadSByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							value = ReadValue<short>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							value = ReadValue<int>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							value = ReadValue<long>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+					break;
+				}
+				case NumberKind.Unsigned:
+				{
+					ulong unsigned;
+					switch (length)
+					{
+						case 1:
+						{
+							unsigned = ReadByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							unsigned = ReadValue<ushort>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							unsigned = ReadValue<uint>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							unsigned = ReadValue<ulong>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (unsigned > Int64.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((Int64)unsigned);
+					break;
+				}
+				case NumberKind.Single:
+				{
+					var real = ReadValue<float>(source, offset: 1, out requestHint);
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (real > Int64.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					if (real < Int64.MinValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((Int64)real);
+					break;
+				}
+				default:
+				{
+					Debug.Assert(kind == NumberKind.Double, $"kind({kind}) == NumberType.Double");
+					var real = ReadValue<double>(source, offset: 1, out requestHint);
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (real > Int64.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					if (real < Int64.MinValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((Int64)real);
+					break;
+				}
+			}
+
+			return true;
+		}
+
+
+		private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type, out byte header, out UInt64 value, out int requestHint)
+		{
+			if (!this.TryPeek(source, out header))
+			{
+				requestHint = 1;
+				value = default;
+				return false;
+			}
+
+			requestHint = 0;
+
+			if (header < 128)
+			{
+				value = header;
+				return true;
+			}
+
+			ParseNumberHeader(header, source, type, out var length, out var kind);
+
+			if ((kind & NumberKind.RealBitMask) != 0 && !this.Options.CanTreatRealAsInteger)
+			{
+				MessagePackThrow.RealCannotBeInteger(header, source.Consumed, type);
+			}
+
+			switch (kind)
+			{
+				case NumberKind.Signed:
+				{
+					long signed;
+					switch (length)
+					{
+						case 1:
+						{
+							signed = ReadSByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							signed = ReadValue<short>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							signed = ReadValue<int>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							signed = ReadValue<long>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (signed < 0)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((ulong)signed);
+					break;
+				}
+				case NumberKind.Unsigned:
+				{
+					switch (length)
+					{
+						case 1:
+						{
+							value = ReadByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							value = ReadValue<ushort>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							value = ReadValue<uint>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							value = ReadValue<ulong>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+					break;
+				}
+				case NumberKind.Single:
+				{
+					var real = ReadValue<float>(source, offset: 1, out requestHint);
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (real > UInt64.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					if (real < UInt64.MinValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((UInt64)real);
+					break;
+				}
+				default:
+				{
+					Debug.Assert(kind == NumberKind.Double, $"kind({kind}) == NumberType.Double");
+					var real = ReadValue<double>(source, offset: 1, out requestHint);
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (real > UInt64.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					if (real < UInt64.MinValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((UInt64)real);
+					break;
+				}
+			}
+
+			return true;
+		}
+
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt
new file mode 100644
index 000000000..898d74a57
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt
@@ -0,0 +1,262 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./MessagePackDecoder.Number.ttinclude" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackDecoder
+	{
+<#
+// -------------- Decode() -------------------
+
+// Signed
+foreach (var type in
+	new []
+	{
+		"SByte",
+		"Int16",
+		"Int32"
+	}
+)
+{
+	this.WriteMethod(type, isSigned: true, is64Bit: false);
+}
+
+this.WriteMethod("Int64", isSigned: true, is64Bit: true);
+
+// Unsigned
+foreach (var type in
+	new []
+	{
+		"Byte",
+		"UInt16",
+		"UInt32"
+	}
+)
+{
+	this.WriteMethod(type, isSigned: false, is64Bit: false);
+}
+
+this.WriteMethod("UInt64", isSigned: false, is64Bit: true);
+
+// ------------- Decode[Uns|S]ignedInteger ------------
+foreach (var isSigned in new [] { true, false })
+{
+	var methodName = $"TryDecode{(isSigned ? "Signed" : "Unsigned")}Integer";
+	var outType = isSigned ? "Int64": "UInt64";
+#>
+
+		private bool <#= methodName #>(in SequenceReader<byte> source, Type type, out byte header, out <#= outType #> value, out int requestHint)
+		{
+			if (!this.TryPeek(source, out header))
+			{
+				requestHint = 1;
+				value = default;
+				return false;
+			}
+
+			requestHint = 0;
+
+			if (header < 128)
+			{
+				value = header;
+				return true;
+			}
+
+<#
+	if (isSigned)
+	{
+#>
+			if (header >= 0xE0)
+			{
+				value = unchecked((sbyte)header);
+				return true;
+			}
+
+<#
+	} // if (isSigned)
+#>
+			ParseNumberHeader(header, source, type, out var length, out var kind);
+
+			if ((kind & NumberKind.RealBitMask) != 0 && !this.Options.CanTreatRealAsInteger)
+			{
+				MessagePackThrow.RealCannotBeInteger(header, source.Consumed, type);
+			}
+
+			switch (kind)
+			{
+				case NumberKind.Signed:
+				{
+<#
+	if (isSigned)
+	{
+		WriteDecodeInteger("value", isSigned: true);
+#>
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+<#
+	}
+	else
+	{
+#>
+					long signed;
+<#
+		WriteDecodeInteger("signed", isSigned: true);
+#>
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (signed < 0)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((ulong)signed);
+<#
+	} // if (isSigned)
+#>
+					break;
+				}
+				case NumberKind.Unsigned:
+				{
+<#
+	if (isSigned)
+	{
+#>
+					ulong unsigned;
+<#
+		WriteDecodeInteger("unsigned", isSigned: false);
+#>
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (unsigned > Int64.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((<#= outType #>)unsigned);
+<#
+	}
+	else
+	{
+		WriteDecodeInteger("value", isSigned: false);
+#>
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+<#
+	} // if (isSigned)
+#>
+					break;
+				}
+				case NumberKind.Single:
+				{
+					var real = ReadValue<float>(source, offset: 1, out requestHint);
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (real > <#= outType #>.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					if (real < <#= outType #>.MinValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((<#= outType #>)real);
+					break;
+				}
+				default:
+				{
+					Debug.Assert(kind == NumberKind.Double, $"kind({kind}) == NumberType.Double");
+					var real = ReadValue<double>(source, offset: 1, out requestHint);
+					if (requestHint != 0)
+					{
+						value = default;
+						return false;
+					}
+
+					if (real > <#= outType #>.MaxValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					if (real < <#= outType #>.MinValue)
+					{
+						MessagePackThrow.IsNotType(header, source.Consumed, type);
+					}
+
+					value = unchecked((<#= outType #>)real);
+					break;
+				}
+			}
+
+			return true;
+		}
+
+<#
+} // foreach (var isSigned)
+#>
+	}
+}
+<#+
+void WriteMethod(string type, bool isSigned, bool is64Bit)
+{
+	var coreMethod = $"TryDecode{(isSigned ? "Signed" : "Unsigned")}Integer";
+	var resultType = isSigned ? "long" : "ulong";
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override <#= type #> Decode<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.<#= coreMethod #>(source, typeof(<#= type #>), out var header, out var result, out requestHint))
+			{
+				return default;
+			}
+<#+
+	if (!is64Bit)
+	{
+#>
+			if (result < <#= type #>.MinValue || result > <#= type #>.MaxValue)
+			{
+				MessagePackThrow.IsNotType(header, source.Consumed, typeof(<#= type #>));
+			}
+
+<#+
+	} // if (!is64Bit)
+#>
+			return unchecked((<#= type #>)result);
+		}
+
+<#+
+}
+#>
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs
new file mode 100644
index 000000000..3dbb8f0b1
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs
@@ -0,0 +1,67 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Internal
+{
+	public partial class MessagePackDecoder
+	{
+		private readonly CollectionItemIterator.CollectionEndDetection _detectCollectionEnds;
+
+		// This is instance method now because CLR/CoreCLR delegates are optmized for instance method invocation.
+		// This method might be changed static if C# supports function pointer.
+		private bool DetectCollectionEnds(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
+		{
+			requestHint = 0;
+
+			if (nextItemIndex >= itemsCount)
+			{
+				return false;
+			}
+
+			nextItemIndex++;
+			return true;
+		}
+
+		public override CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint)
+		{
+			var consumed = 0L;
+			var type = this.PrivateDecodeArrayOrMapHeader(source, ref consumed, out _, out var itemsCount, out requestHint);
+			if (requestHint != 0)
+			{
+				iterator = default;
+				return default;
+			}
+
+			iterator = this.CreateIterator(itemsCount);
+			return type;
+		}
+
+		private CollectionItemIterator CreateIterator(long itemsCount)
+			=> new CollectionItemIterator(this._detectCollectionEnds, itemsCount);
+
+		public override CollectionItemIterator DecodeArray(in SequenceReader<byte> source, out int requestHint)
+		{
+			var itemsCount = this.DecodeArrayHeader(source, out requestHint);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			return new CollectionItemIterator(this._detectCollectionEnds, itemsCount);
+		}
+
+		public override CollectionItemIterator DecodeMap(in SequenceReader<byte> source, out int requestHint)
+		{
+			var itemsCount = this.DecodeMapHeader(source, out requestHint);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			return new CollectionItemIterator(this._detectCollectionEnds, itemsCount);
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs
new file mode 100644
index 000000000..0ca842cdc
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs
@@ -0,0 +1,161 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackDecoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Byte? DecodeNullableByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeByte(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override SByte? DecodeNullableSByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeSByte(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int16? DecodeNullableInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeInt16(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt16? DecodeNullableUInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeUInt16(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int32? DecodeNullableInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeInt32(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt32? DecodeNullableUInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeUInt32(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int64? DecodeNullableInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeInt64(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt64? DecodeNullableUInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeUInt64(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Single? DecodeNullableSingle(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeSingle(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Double? DecodeNullableDouble(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeDouble(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Boolean? DecodeNullableBoolean(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeBoolean(source, out requestHint);
+		}
+
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt
new file mode 100644
index 000000000..b73b9c7fc
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt
@@ -0,0 +1,55 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackDecoder
+	{
+<#
+foreach (var type in
+	new []
+	{
+		"Byte",
+		"SByte",
+		"Int16",
+		"UInt16",
+		"Int32",
+		"UInt32",
+		"Int64",
+		"UInt64",
+		"Single",
+		"Double",
+		"Boolean"
+	}
+)
+{
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override <#= type #>? DecodeNullable<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.Decode<#= type #>(source, out requestHint);
+		}
+
+<#
+} // foreach (var type)
+#>
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude b/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude
new file mode 100644
index 000000000..33d1a85d5
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude
@@ -0,0 +1,32 @@
+<#+
+void WriteDecodeInteger(string variable, bool isSigned)
+{
+#>
+					switch (length)
+					{
+						case 1:
+						{
+							<#= variable #> = Read<#= isSigned ? "SByte" : "Byte" #>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							<#= variable #> = ReadValue<<#= isSigned ? "short" : "ushort" #>>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							<#= variable #> = ReadValue<<#= isSigned ? "int" : "uint" #>>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							<#= variable #> = ReadValue<<#= isSigned ? "long" : "ulong" #>>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+<#+
+}
+#>
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs
new file mode 100644
index 000000000..0d5d871e7
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs
@@ -0,0 +1,223 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackDecoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Single DecodeSingle(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryPeek(source, out var header))
+			{
+				requestHint = 1;
+				return default;
+			}
+
+			requestHint = 0;
+
+			if (header < 128 || header >= 0xE0)
+			{
+				source.Advance(1);
+				return header;
+			}
+
+			ParseNumberHeader(header, source, typeof(Single), out var length, out var kind);
+
+			Single value;
+			switch (kind)
+			{
+				case NumberKind.Signed:
+				{
+					switch (length)
+					{
+						case 1:
+						{
+							value = ReadSByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							value = ReadValue<short>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							value = ReadValue<int>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							value = ReadValue<long>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					break;
+				}
+				case NumberKind.Unsigned:
+				{
+					switch (length)
+					{
+						case 1:
+						{
+							value = ReadByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							value = ReadValue<ushort>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							value = ReadValue<uint>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							value = ReadValue<ulong>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					break;
+				}
+				case NumberKind.Single:
+				{
+					value = ReadValue<float>(source, offset: 1, out requestHint);
+					break;
+				}
+				default:
+				{
+					// Double
+					value = (Single)ReadValue<double>(source, offset: 1, out requestHint);
+					break;
+				}
+			}
+
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			return value;
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Double DecodeDouble(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryPeek(source, out var header))
+			{
+				requestHint = 1;
+				return default;
+			}
+
+			requestHint = 0;
+
+			if (header < 128 || header >= 0xE0)
+			{
+				source.Advance(1);
+				return header;
+			}
+
+			ParseNumberHeader(header, source, typeof(Double), out var length, out var kind);
+
+			Double value;
+			switch (kind)
+			{
+				case NumberKind.Signed:
+				{
+					switch (length)
+					{
+						case 1:
+						{
+							value = ReadSByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							value = ReadValue<short>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							value = ReadValue<int>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							value = ReadValue<long>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					break;
+				}
+				case NumberKind.Unsigned:
+				{
+					switch (length)
+					{
+						case 1:
+						{
+							value = ReadByte(source, offset: 1, out requestHint);
+							break;
+						}
+						case 2:
+						{
+							value = ReadValue<ushort>(source, offset: 1, out requestHint);
+							break;
+						}
+						case 4:
+						{
+							value = ReadValue<uint>(source, offset: 1, out requestHint);
+							break;
+						}
+						default: 
+						{
+							Debug.Assert(length == 8, $"length({length}) != 8");
+							value = ReadValue<ulong>(source, offset: 1, out requestHint);
+							break;
+						}
+					}
+
+					break;
+				}
+				case NumberKind.Single:
+				{
+					value = ReadValue<float>(source, offset: 1, out requestHint);
+					break;
+				}
+				default:
+				{
+					// Double
+					value = ReadValue<double>(source, offset: 1, out requestHint);
+					break;
+				}
+			}
+
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			return value;
+		}
+
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt
new file mode 100644
index 000000000..cd5e02e09
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt
@@ -0,0 +1,100 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./MessagePackDecoder.Number.ttinclude" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackDecoder
+	{
+<#
+foreach (var type in new [] { "Single", "Double" })
+{
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override <#= type #> Decode<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryPeek(source, out var header))
+			{
+				requestHint = 1;
+				return default;
+			}
+
+			requestHint = 0;
+
+			if (header < 128 || header >= 0xE0)
+			{
+				source.Advance(1);
+				return header;
+			}
+
+			ParseNumberHeader(header, source, typeof(<#= type #>), out var length, out var kind);
+
+			<#= type #> value;
+			switch (kind)
+			{
+				case NumberKind.Signed:
+				{
+<#
+	WriteDecodeInteger("value", isSigned: true);
+#>
+					break;
+				}
+				case NumberKind.Unsigned:
+				{
+<#
+	WriteDecodeInteger("value", isSigned: false);
+#>
+					break;
+				}
+				case NumberKind.Single:
+				{
+					value = ReadValue<float>(source, offset: 1, out requestHint);
+					break;
+				}
+				default:
+				{
+					// Double
+<#
+	if (type != "Double")
+	{
+#>
+					value = (<#= type #>)ReadValue<double>(source, offset: 1, out requestHint);
+<#
+	}
+	else
+	{
+#>
+					value = ReadValue<double>(source, offset: 1, out requestHint);
+<#
+	}
+#>
+					break;
+				}
+			}
+
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			return value;
+		}
+
+<#
+} // foreach (var isSigned)
+#>
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs
new file mode 100644
index 000000000..2f343f721
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs
@@ -0,0 +1,281 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	public partial class MessagePackDecoder
+	{
+		public sealed override void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default)
+			=> this.Drain(source, collectionContext, itemsCount: 1, out requestHint, cancellationToken);
+
+		public override void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var consumed = 0L;
+			if (!this.SkipItems(source, collectionContext, itemsCount, ref consumed, out requestHint, cancellationToken))
+			{
+				source.Rewind(consumed);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool SkipLength(in SequenceReader<byte> source, long length, ref long consumed, out int requestHint)
+		{
+			if (source.Remaining < length)
+			{
+				requestHint = (int)((length - source.Remaining) & Int32.MaxValue);
+				return false;
+			}
+
+			requestHint = 0;
+			source.Advance(length);
+			consumed += length;
+			return true;
+		}
+
+		private bool SkipArray(in SequenceReader<byte> source, in CollectionContext collectionContext, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			collectionContext.IncrementDepth();
+
+			var initialConsumed = consumed;
+			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var arrayLength, out requestHint);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			if (!type.IsArray)
+			{
+				MessagePackThrow.TypeIsNotArray(header, source.Consumed - consumed + initialConsumed);
+			}
+
+			if (!this.SkipItems(source, collectionContext, arrayLength, ref consumed, out requestHint, cancellationToken))
+			{
+				return false;
+			}
+
+			collectionContext.DecrementDepth();
+			return true;
+		}
+
+		private bool SkipMap(in SequenceReader<byte> source, in CollectionContext collectionContext, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			collectionContext.IncrementDepth();
+
+			var initialConsumed = consumed;
+			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var mapCount, out requestHint);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			if (!type.IsMap)
+			{
+				MessagePackThrow.TypeIsNotMap(header, source.Consumed - consumed + initialConsumed);
+			}
+
+			if (!this.SkipItems(source, collectionContext, mapCount * 2, ref consumed, out requestHint, cancellationToken))
+			{
+				return false;
+			}
+
+			collectionContext.DecrementDepth();
+			return true;
+		}
+
+		private bool SkipItems(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			while (itemsCount > 0)
+			{
+				if (!this.TryPeek(source, out var header))
+				{
+					requestHint = 1;
+					return false;
+				}
+
+				consumed++;
+
+				var length = 0L;
+
+				if (header >= MessagePackCode.MinimumFixedArray && header <= MessagePackCode.MaximumFixedArray)
+				{
+					if (!this.SkipArray(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+					{
+						return false;
+					}
+				}
+				else if (header >= MessagePackCode.MinimumFixedMap && header <= MessagePackCode.MaximumFixedMap)
+				{
+					if (!this.SkipMap(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+					{
+						return false;
+					}
+				}
+				else if (header >= MessagePackCode.MinimumFixedRaw && header <= MessagePackCode.MaximumFixedRaw)
+				{
+					length = header - MessagePackCode.MinimumFixedRaw;
+				}
+				else
+				{
+					switch (header)
+					{
+						case MessagePackCode.SignedInt8:
+						case MessagePackCode.UnsignedInt8:
+						{
+							length = 1;
+							break;
+						}
+						case MessagePackCode.SignedInt16:
+						case MessagePackCode.UnsignedInt16:
+						case MessagePackCode.Real32:
+						case MessagePackCode.SignedInt32:
+						case MessagePackCode.UnsignedInt32:
+						{
+							length = 4;
+							break;
+						}
+						case MessagePackCode.Real64:
+						case MessagePackCode.SignedInt64:
+						case MessagePackCode.UnsignedInt64:
+						{
+							length = 8;
+							break;
+						}
+						case MessagePackCode.Bin8:
+						{
+							if (!source.TryRead(out var b))
+							{
+								requestHint = 1;
+								return false;
+							}
+
+							length = b;
+							consumed++;
+							break;
+						}
+						case MessagePackCode.Bin16:
+						case MessagePackCode.Raw16:
+						{
+							length = ReadValue<ushort>(source, offset: 0, out requestHint);
+							if (requestHint != 0)
+							{
+								source.Rewind(consumed);
+								return false;
+							}
+
+							consumed += sizeof(ushort);
+							break;
+						}
+						case MessagePackCode.Bin32:
+						case MessagePackCode.Raw32:
+						{
+							length = ReadValue<uint>(source, offset: 0, out requestHint);
+							if (requestHint != 0)
+							{
+								source.Rewind(consumed);
+								return false;
+							}
+
+							consumed += sizeof(int);
+							break;
+						}
+						case MessagePackCode.FixExt1:
+						{
+							length = 2;
+							break;
+						}
+						case MessagePackCode.FixExt2:
+						{
+							length = 3;
+							break;
+						}
+						case MessagePackCode.FixExt4:
+						{
+							length = 5;
+							break;
+						}
+						case MessagePackCode.FixExt8:
+						{
+							length = 9;
+							break;
+						}
+						case MessagePackCode.FixExt16:
+						{
+							length = 17;
+							break;
+						}
+						case MessagePackCode.Ext8:
+						{
+							if (!source.TryRead(out var b))
+							{
+								requestHint = 1;
+								return false;
+							}
+
+							length = b + 1;
+							consumed++;
+							break;
+						}
+						case MessagePackCode.Ext16:
+						{
+							length = ReadValue<ushort>(source, offset: 0, out requestHint);
+							if (requestHint != 0)
+							{
+								source.Rewind(consumed);
+								return false;
+							}
+
+							consumed += sizeof(ushort) + 1;
+							break;
+						}
+						case MessagePackCode.Ext32:
+						{
+							length = ReadValue<int>(source, offset: 0, out requestHint);
+							if (requestHint != 0)
+							{
+								source.Rewind(consumed);
+								return false;
+							}
+
+							consumed += sizeof(int) + 1;
+							break;
+						}
+						case MessagePackCode.Array16:
+						case MessagePackCode.Array32:
+						{
+							if (!this.SkipArray(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+							{
+								return false;
+							}
+							break;
+						}
+						case MessagePackCode.Map16:
+						case MessagePackCode.Map32:
+						{
+							if (!this.SkipMap(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+							{
+								return false;
+							}
+							break;
+						}
+					}
+				}
+
+				if (length > 0 && !SkipLength(source, length, ref consumed, out requestHint))
+				{
+					return false;
+				}
+
+				itemsCount--;
+			} // while (itemsCount > 0)
+
+			requestHint = 0;
+			return true;
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs
new file mode 100644
index 000000000..04f043e73
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs
@@ -0,0 +1,283 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	public partial class MessagePackDecoder
+	{
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override bool GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var length = this.PeekRawStringLength(source, out requestHint, cancellationToken);
+			if (length < 0)
+			{
+				rawString = default;
+				return false;
+			}
+
+			if (source.UnreadSpan.Length < length)
+			{
+				rawString = source.UnreadSpan.Slice(0, length);
+				source.Advance(length);
+				requestHint = 0;
+				return true;
+			}
+
+			return this.GetRawStringMultiSegment(source, out rawString, out requestHint, length, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private bool GetRawStringMultiSegment(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, int length, CancellationToken cancellationToken)
+		{
+			if (source.Remaining < length)
+			{
+				requestHint = length - (int)source.Remaining;
+				rawString = default;
+				return false;
+			}
+
+			var result = new byte[length];
+			var bufferSpan = result.AsSpan();
+
+			var copyLength = Math.Min(this.Options.CancellationSupportThreshold, length);
+			while (bufferSpan.Length > 0)
+			{
+				var destination = bufferSpan.Slice(0, copyLength);
+				var shouldTrue = source.TryCopyTo(destination);
+				Debug.Assert(shouldTrue, "SequenceReader<byte>.Remaining lied.");
+
+				bufferSpan = bufferSpan.Slice(copyLength);
+				source.Advance(copyLength);
+
+				cancellationToken.ThrowIfCancellationRequested();
+			}
+
+			rawString = result;
+			requestHint = 0;
+			return true;
+		}
+
+		private int PeekRawStringLength(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken)
+		{
+			var length = this.DecodeStringHeader(source, out var header, out requestHint, out _);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			if (length > Int32.MaxValue)
+			{
+				MessagePackThrow.TooLargeByteLength(header, source.Consumed, length);
+			}
+
+			return (int)length;
+		}
+
+		private long DecodeStringHeader(in SequenceReader<byte> source, out byte header, out int requestHint, out int consumed)
+		{
+			if (!this.TryPeek(source, out header))
+			{
+				requestHint = 1;
+				consumed = 0;
+				return 0;
+			}
+
+			if (header >= MessagePackCode.MinimumFixedRaw && header <= MessagePackCode.MaximumFixedRaw)
+			{
+				requestHint = 0;
+				consumed = 1;
+				return header - MessagePackCode.MinimumFixedRaw;
+			}
+
+			long length;
+			switch (header)
+			{
+				case MessagePackCode.Str8:
+				{
+					length = ReadByte(source, offset: 1, out requestHint);
+					consumed = 2;
+					break;
+				}
+				case MessagePackCode.Str16:
+				{
+					length = ReadValue<ushort>(source, offset: 1, out requestHint);
+					consumed = 3;
+					break;
+				}
+				case MessagePackCode.Str32:
+				{
+					length = ReadValue<uint>(source, offset: 1, out requestHint);
+					consumed = 5;
+					break;
+				}
+				default:
+				{
+					MessagePackThrow.IsNotUtf8String(header, source.Consumed);
+					// never
+					requestHint = default;
+					consumed = default;
+					return 0;
+				}
+			}
+
+			return requestHint == 0 ? length : 0;
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override string? DecodeNullableString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeString(source, out requestHint, encoding, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override string? DecodeString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var length = this.DecodeStringHeader(source, out _, out requestHint, out var consumed);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			if (source.Remaining < length + consumed)
+			{
+				requestHint = (int)((length + consumed - source.Remaining) & Int32.MaxValue);
+				return default;
+			}
+
+			if (length > this.Options.MaxBinaryLengthInBytes)
+			{
+				Throw.StringLengthExceeded(source.Consumed - consumed, length, this.Options.MaxBinaryLengthInBytes);
+			}
+
+			if (encoding == null && length <= this.Options.CancellationSupportThreshold)
+			{
+				// fast-path
+				var value = Utf8EncodingNonBom.Instance.GetString(source.UnreadSpan.Slice(consumed, (int)length));
+				source.Advance(length + consumed);
+				requestHint = 0;
+				return value;
+			}
+
+			var result = (encoding ?? Utf8EncodingNonBom.Instance).GetStringMultiSegment(source.Sequence.Slice(consumed), this.Options.CharBufferPool, cancellationToken);
+			source.Advance(length + consumed);
+			requestHint = 0;
+			return result;
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override byte[]? DecodeNullableBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeBinary(source, out requestHint, cancellationToken);
+		}
+
+		private int DecodeBinaryHeader(in SequenceReader<byte> source, out int requestHint, out int consumed)
+		{
+			if (!this.TryPeek(source, out var header))
+			{
+				requestHint = 1;
+				consumed = 0;
+				return 0;
+			}
+
+			if (header >= MessagePackCode.MinimumFixedRaw && header <= MessagePackCode.MaximumFixedRaw)
+			{
+				requestHint = 0;
+				consumed = 1;
+				return header - MessagePackCode.MinimumFixedRaw;
+			}
+
+			int length;
+			switch (header)
+			{
+				case MessagePackCode.Str8:
+				case MessagePackCode.Bin8:
+				{
+					length = ReadByte(source, offset: 1, out requestHint);
+					consumed = 2;
+					break;
+				}
+				case MessagePackCode.Str16:
+				case MessagePackCode.Bin16:
+				{
+					length = ReadValue<ushort>(source, offset: 1, out requestHint);
+					consumed = 3;
+					break;
+				}
+				case MessagePackCode.Str32:
+				case MessagePackCode.Bin32:
+				{
+					length = ReadValue<int>(source, offset: 1, out requestHint);
+					if (length < 0)
+					{
+						MessagePackThrow.TooLargeByteLength(header, source.Consumed - 5, unchecked((uint)length));
+					}
+
+					consumed = 5;
+					break;
+				}
+				default:
+				{
+					MessagePackThrow.IsNotUtf8String(header, source.Consumed);
+					// never
+					requestHint = default;
+					consumed = default;
+					return 0;
+				}
+			}
+
+			return requestHint == 0 ? length : 0;
+		}
+
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override byte[]? DecodeBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var length = this.DecodeBinaryHeader(source, out requestHint, out var consumed);
+			if(requestHint != 0)
+			{
+				return default;
+			}
+
+			if (length > this.Options.MaxBinaryLengthInBytes)
+			{
+				Throw.BinaryLengthExceeded(source.Consumed - consumed, length, this.Options.MaxBinaryLengthInBytes);
+			}
+
+			if(source.Remaining < length + consumed)
+			{
+				requestHint = length + consumed - (int)source.Remaining;
+				return default;
+			}
+
+			// This line may throw OutOfMemoryException, but we cannot determine the OOM is caused by heap exhausion or excess of the implementation specific max length of arrays.
+			// So, we just throws OOM for such conditions.
+			var result = new byte[length];
+			var shouldBeTrue = source.TryCopyTo(result);
+			Debug.Assert(shouldBeTrue, "SequenceReader<byte>.Remaining lied.");
+			source.Advance(length);
+			return result;
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
new file mode 100644
index 000000000..177a22159
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
@@ -0,0 +1,184 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace MsgPack.Internal
+{
+	public sealed partial class MessagePackDecoder : Decoder
+	{
+		private static readonly FormatFeatures MessagePackFormatFeatures =
+			new FormatFeaturesBuilder
+			{
+				IsContextful = false,
+				CanCountCollectionItems = true,
+				CanSpecifyStringEncoding = true
+			}.Build();
+
+		public MessagePackDecoder(MessagePackDecoderOptions options)
+			: base(options, MessagePackFormatFeatures)
+		{
+			this._detectCollectionEnds = this.DetectCollectionEnds;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override bool DecodeBoolean(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (!this.TryPeek(source, out var header))
+			{
+				requestHint = 1;
+				return false;
+			}
+
+			requestHint = 0;
+			switch (header)
+			{
+				case MessagePackCode.TrueValue:
+				{
+					source.Advance(1);
+					return true;
+				}
+				case MessagePackCode.FalseValue:
+				{
+					source.Advance(1);
+					return false;
+				}
+				default:
+				{
+					MessagePackThrow.IsNotType(header, source.Consumed, typeof(bool));
+					// Never reached.
+					return false;
+				}
+			}
+		}
+
+		private bool TryReadNull(in SequenceReader<byte> source)
+		{
+			if (this.TryPeek(source, out var b) && b == MessagePackCode.NilValue)
+			{
+				source.Advance(1);
+				return true;
+			}
+
+			return false;
+		}
+
+		private static void ParseNumberHeader(byte header, in SequenceReader<byte> source, Type type, out int length, out NumberKind kind)
+		{
+			// 0xD0-D3 -- SignedIntN
+			// 1101-0000 -> 1101-0011
+			// 0xCC-CF -- UnsignedIntN
+			// 1100-1100 -> 1100-1111
+			// 0XCA-CB -- RealN
+			// 1100-1010 -> 1100-1011
+
+			if ((header & 0xD3) == header)
+			{
+				// SignedIntN
+				length = (int)Math.Pow(2, (header & 0x3)) + 1;
+				kind = NumberKind.Signed;
+			}
+			else if ((header & 0xCC) == header)
+			{
+				// UnsignedIntN
+				length = (int)Math.Pow(2, (header & 0x3)) + 1;
+				kind = NumberKind.Unsigned;
+			}
+			if (header == MessagePackCode.Real64)
+			{
+				length = 9;
+				kind = NumberKind.Double;
+			}
+			else if (header == MessagePackCode.Real32)
+			{
+				length = 5;
+				kind = NumberKind.Single;
+			}
+			else
+			{
+				MessagePackThrow.IsNotNumber(header, source.Consumed, type);
+				length = default;
+				kind = NumberKind.Unknown;
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static byte ReadByte(in SequenceReader<byte> source, int offset, out int requestHint)
+		{
+			if (source.UnreadSpan.Length > offset + 1)
+			{
+				var result = source.UnreadSpan[offset];
+				source.Advance(offset + 1);
+				requestHint = 0;
+				return result;
+			}
+
+			return ReadByteMultiSegment(source, offset, out requestHint);
+		}
+
+		private static byte ReadByteMultiSegment(in SequenceReader<byte> source, int offset, out int requestHint)
+		{
+			if (source.Remaining < offset + 1)
+			{
+				requestHint = 1;
+				return default;
+			}
+
+			Span<byte> buffer = stackalloc byte[offset + 1];
+			source.TryCopyTo(buffer);
+			source.Advance(offset + 1);
+			requestHint = 0;
+			return buffer[offset];
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static sbyte ReadSByte(in SequenceReader<byte> source, int offset, out int requestHint)
+			=> unchecked((sbyte)ReadByte(source, offset, out requestHint));
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static unsafe T ReadValue<T>(in SequenceReader<byte> source, int offset, out int requestHint)
+			where T : unmanaged
+		{
+			if (source.UnreadSpan.Length > offset + sizeof(T))
+			{
+				var result = Unsafe.ReadUnaligned<T>(ref MemoryMarshal.GetReference(source.UnreadSpan.Slice(offset)));
+				source.Advance(offset + sizeof(T));
+				requestHint = 0;
+				return result;
+			}
+
+			return ReadMultiSegment<T>(source, offset, out requestHint);
+		}
+
+		private static unsafe T ReadMultiSegment<T>(in SequenceReader<byte> source, int offset, out int requestHint)
+				where T : unmanaged
+		{
+			if (source.Remaining < offset + sizeof(T))
+			{
+				requestHint = offset + sizeof(T) - (int)source.Remaining;
+				return default;
+			}
+
+			Span<byte> buffer = stackalloc byte[offset + sizeof(T)];
+			source.TryCopyTo(buffer);
+			source.Advance(offset + sizeof(T));
+			requestHint = 0;
+			return Unsafe.ReadUnaligned<T>(ref MemoryMarshal.GetReference(buffer.Slice(offset)));
+		}
+
+		private enum NumberKind
+		{
+			Unknown = 0,
+			Unsigned = 0x1,
+			Signed = 0x2,
+			Half = 0x11,
+			Single = 0x12,
+			Double = 0x13,
+			RealBitMask = 0x10
+		}
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs b/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
new file mode 100644
index 000000000..b4415c2a4
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
@@ -0,0 +1,12 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	public sealed class MessagePackDecoderOptions : DecoderOptions
+	{
+		internal MessagePackDecoderOptions(MessagePackDecoderOptionsBuilder builder)
+			: base(builder) { }
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs b/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs
new file mode 100644
index 000000000..291e429b8
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs
@@ -0,0 +1,13 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	public sealed class MessagePackDecoderOptionsBuilder : DecoderOptionsBuilder
+	{
+		public MessagePackDecoderOptionsBuilder() { }
+
+		public MessagePackDecoderOptions Build() => new MessagePackDecoderOptions(this);
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs
new file mode 100644
index 000000000..d38e4fd18
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs
@@ -0,0 +1,190 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackEncoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeInt32(Int32 value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var leastByte = value & 0x000000FF;
+			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(leastByte));
+				buffer.Advance(1);
+			}
+			else
+			{
+				this.EncodeSlow(value, buffer);
+			}
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeUInt32(UInt32 value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var leastByte = value & 0x000000FF;
+			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(leastByte));
+				buffer.Advance(1);
+			}
+			else
+			{
+				this.EncodeSlow(value, buffer);
+			}
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeInt64(Int64 value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var leastByte = value & 0x000000FF;
+			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(leastByte));
+				buffer.Advance(1);
+			}
+			else
+			{
+				this.EncodeSlow(value, buffer);
+			}
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeUInt64(UInt64 value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var leastByte = value & 0x000000FF;
+			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(leastByte));
+				buffer.Advance(1);
+			}
+			else
+			{
+				this.EncodeSlow(value, buffer);
+			}
+		}
+
+		private void EncodeSlow(int value, IBufferWriter<byte> buffer)
+		{
+			if (value >= SByte.MinValue && value <= SByte.MaxValue)
+			{
+				// SingedInt8 (SByte)
+				var span = buffer.GetSpan(2);
+				span[1] = unchecked((byte)(sbyte)value);
+				span[0] = MessagePackCode.SignedInt8;
+				buffer.Advance(2);
+			}
+			else if (value >= Int16.MinValue && value <= Int16.MaxValue)
+			{
+				// SignedInt16 (Int16)
+				var span = buffer.GetSpan(3);
+				span[0] = MessagePackCode.SignedInt16;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteInt16BigEndian(span, unchecked((Int16)value));
+				buffer.Advance(3);
+			}
+			else
+			{
+				// SignedInt32 (Int32)
+				var span = buffer.GetSpan(5);
+				span[0] = MessagePackCode.SignedInt32;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteInt32BigEndian(span, unchecked((Int32)value));
+				buffer.Advance(5);
+			}
+		} // EncodeSlow(int)
+
+		private void EncodeSlow(uint value, IBufferWriter<byte> buffer)
+		{
+			if (value <= Byte.MaxValue)
+			{
+				// UnsingedInt8 (Byte)
+				var span = buffer.GetSpan(2);
+				span[1] = unchecked((byte)value);
+				span[0] = MessagePackCode.UnsignedInt8;
+				buffer.Advance(2);
+			}
+			else if (value <= UInt16.MaxValue)
+			{
+				// UnsignedInt16 (UInt16)
+				var span = buffer.GetSpan(3);
+				span[0] = MessagePackCode.UnsignedInt16;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteUInt16BigEndian(span, unchecked((UInt16)value));
+				buffer.Advance(3);
+			}
+			else
+			{
+				// UnsignedInt32 (UInt32)
+				var span = buffer.GetSpan(5);
+				span[0] = MessagePackCode.UnsignedInt32;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteUInt32BigEndian(span, unchecked((UInt32)value));
+				buffer.Advance(5);
+			}
+		} // EncodeSlow(uint)
+
+		private void EncodeSlow(long value, IBufferWriter<byte> buffer)
+		{
+			if (value <= Int32.MaxValue && value >= Int32.MinValue)
+			{
+				this.EncodeSlow(unchecked((int)value), buffer);
+			}
+			else
+			{
+				// SignedInt64 (Int64)
+				var span = buffer.GetSpan(9);
+				span[0] = MessagePackCode.SignedInt64;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteInt64BigEndian(span, unchecked((Int64)value));
+				buffer.Advance(9);
+			}
+		} // EncodeSlow(long)
+
+		private void EncodeSlow(ulong value, IBufferWriter<byte> buffer)
+		{
+			if (value <= UInt32.MaxValue)
+			{
+				this.EncodeSlow(unchecked((uint)value), buffer);
+			}
+			else
+			{
+				// UnsignedInt64 (UInt64)
+				var span = buffer.GetSpan(9);
+				span[0] = MessagePackCode.UnsignedInt64;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteUInt64BigEndian(span, unchecked((UInt64)value));
+				buffer.Advance(9);
+			}
+		} // EncodeSlow(ulong)
+
+	}
+}
+
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt
new file mode 100644
index 000000000..d82abb48f
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt
@@ -0,0 +1,137 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackEncoder
+	{
+<#
+foreach (var inputType in new []{ "Int32", "UInt32", "Int64", "UInt64" })
+{
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void Encode<#= inputType #>(<#= inputType #> value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var leastByte = value & 0x000000FF;
+			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(leastByte));
+				buffer.Advance(1);
+			}
+			else
+			{
+				this.EncodeSlow(value, buffer);
+			}
+		}
+
+<#
+} // public int/long
+#>
+		private void EncodeSlow(int value, IBufferWriter<byte> buffer)
+		{
+			if (value >= SByte.MinValue && value <= SByte.MaxValue)
+			{
+				// SingedInt8 (SByte)
+				var span = buffer.GetSpan(2);
+				span[1] = unchecked((byte)(sbyte)value);
+				span[0] = MessagePackCode.SignedInt8;
+				buffer.Advance(2);
+			}
+			else if (value >= Int16.MinValue && value <= Int16.MaxValue)
+			{
+<#
+	WriteEncodeSlowBody("Int16", sizeof(short) + 1, "SignedInt16");
+#>
+			}
+			else
+			{
+<#
+	WriteEncodeSlowBody("Int32", sizeof(int) + 1, "SignedInt32");
+#>
+			}
+		} // EncodeSlow(int)
+
+		private void EncodeSlow(uint value, IBufferWriter<byte> buffer)
+		{
+			if (value <= Byte.MaxValue)
+			{
+				// UnsingedInt8 (Byte)
+				var span = buffer.GetSpan(2);
+				span[1] = unchecked((byte)value);
+				span[0] = MessagePackCode.UnsignedInt8;
+				buffer.Advance(2);
+			}
+			else if (value <= UInt16.MaxValue)
+			{
+<#
+	WriteEncodeSlowBody("UInt16", sizeof(ushort) + 1, "UnsignedInt16");
+#>
+			}
+			else
+			{
+<#
+	WriteEncodeSlowBody("UInt32", sizeof(uint) + 1, "UnsignedInt32");
+#>
+			}
+		} // EncodeSlow(uint)
+
+		private void EncodeSlow(long value, IBufferWriter<byte> buffer)
+		{
+			if (value <= Int32.MaxValue && value >= Int32.MinValue)
+			{
+				this.EncodeSlow(unchecked((int)value), buffer);
+			}
+			else
+			{
+<#
+	WriteEncodeSlowBody("Int64", sizeof(long) + 1, "SignedInt64");
+#>
+			}
+		} // EncodeSlow(long)
+
+		private void EncodeSlow(ulong value, IBufferWriter<byte> buffer)
+		{
+			if (value <= UInt32.MaxValue)
+			{
+				this.EncodeSlow(unchecked((uint)value), buffer);
+			}
+			else
+			{
+<#
+	WriteEncodeSlowBody("UInt64", sizeof(ulong) + 1, "UnsignedInt64");
+#>
+			}
+		} // EncodeSlow(ulong)
+
+	}
+}
+
+<#+
+private void WriteEncodeSlowBody(string typeName, int size, string code)
+{
+#>
+				// <#= code #> (<#= typeName #>)
+				var span = buffer.GetSpan(<#= size #>);
+				span[0] = MessagePackCode.<#= code #>;
+				span = span.Slice(1);
+				BinaryPrimitives.Write<#= typeName #>BigEndian(span, unchecked((<#= typeName #>)value));
+				buffer.Advance(<#= size #>);
+<#+
+}
+#>
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
new file mode 100644
index 000000000..cd5b82f23
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
@@ -0,0 +1,272 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackEncoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			buffer = EnsureNotNull(buffer);
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+			if (value.Length == 0)
+			{
+				buffer.GetSpan(1)[0] = MessagePackCode.MinimumFixedRaw;
+				buffer.Advance(1);
+				return;
+			}
+
+			if (value.Length < 256)
+			{
+				var valueLength = unchecked((int)value.Length);
+				var maxByteLength = encoding.GetMaxByteCount(valueLength);
+
+				if (maxByteLength < 32)
+				{
+					// stack alloc is fastest
+					Span<byte> encodingBuffer = stackalloc byte[maxByteLength];
+					var actualLength = encoding.GetBytes(value, encodingBuffer);
+					var sink = buffer.GetSpan(actualLength + 1);
+					sink[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | actualLength));
+					encodingBuffer.Slice(actualLength).CopyTo(sink.Slice(1));
+					buffer.Advance(sink.Length);
+					return;
+				}
+				else if (maxByteLength < 256)
+				{
+					// stack alloc is fastest
+					Span<byte> encodingBuffer = stackalloc byte[maxByteLength + 3];
+					var actualLength = encoding.GetBytes(value, encodingBuffer);
+					var sink = buffer.GetSpan(3);
+					var headerLength = this.EncodeStringHeader(unchecked((uint)actualLength), sink);
+					buffer.Advance(headerLength);
+					encodingBuffer.Slice(0, actualLength).CopyTo(buffer.GetSpan(actualLength));
+					buffer.Advance(actualLength);
+					return;
+				}
+			}
+
+			this.EncodeStringSlow(value, buffer, encoding);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private void EncodeStringSlow(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			// Use 1-path logic borrowed from MessagePack C#
+
+			// Get max char bytes. Use 2 for 0 (maybe bug) or 1 (ASCII) to simplify following logic.
+			var maxBytesPerChar = Math.Max(encoding.GetMaxByteCount(1), 2);
+
+			// In most case, msgpack uses UTF-8 and clob contains 1 to 3 byte chars,
+			// and may charactors are ASCII.
+			// So, estimate with 1char is 2bytes is good enough here.
+			var estimatedLength = unchecked((uint)value.Length * 2);
+			var bufferLength = encoding.GetMaxByteCount(unchecked((int)value.Length)) + 5;
+
+			if (bufferLength <= 0x20_0000) // 2MB
+			{
+				Memory<byte> sinkMemory = buffer.GetMemory(bufferLength);
+
+				if (MemoryMarshal.TryGetArray<byte>(sinkMemory, out var sinkBufferSegment))
+				{
+					// We can get single array
+					buffer.Advance(this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, sinkBufferSegment));
+				}
+				else
+				{
+					// Memory is not array backend, so use local buffer.
+					var encodingBuffer = base.Options.ByteBufferPool.Rent(bufferLength);
+					try
+					{
+						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
+						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
+					}
+					finally
+					{
+						base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
+					}
+				}
+			}
+
+			this.EncodeHugeString2Path(value, buffer, encoding);
+		}
+
+		
+		private unsafe int EncodeLargeString1Path(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding encoding, uint estimatedLength, ArraySegment<byte> sinkBufferSegment)
+		{
+			ref var head = ref sinkBufferSegment.Array![sinkBufferSegment.Offset];
+
+			Span<byte> sinkBuffer = sinkBufferSegment;
+			var estimatedHeaderLength = this.EncodeStringHeader(estimatedLength, sinkBuffer);
+
+			int actualLength;
+
+			try
+			{
+				actualLength = encoding.GetBytes(value, sinkBuffer.Slice(estimatedHeaderLength));
+			}
+			catch (OverflowException ex)
+			{
+				Throw.TooLargeByteLength(ex, encoding.EncodingName);
+				return 0;
+			}
+
+			var realHeaderLength = this.EncodeStringHeader(unchecked((uint)actualLength), sinkBuffer);
+
+			if (estimatedHeaderLength != realHeaderLength)
+			{
+				fixed (byte* pSinkBuffer = &head)
+				{
+					Buffer.MemoryCopy((void*)(pSinkBuffer + estimatedHeaderLength), (void*)(pSinkBuffer + realHeaderLength), actualLength, actualLength);
+				}
+			}
+
+			return actualLength + realHeaderLength;
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			buffer = EnsureNotNull(buffer);
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+			if (value.Length > UInt32.MaxValue)
+			{
+				Throw.TooLargeCharLength(value.Length);
+				return;
+			}
+
+			if (value.Length == 0)
+			{
+				buffer.GetSpan(1)[0] = MessagePackCode.MinimumFixedRaw;
+				buffer.Advance(1);
+				return;
+			}
+
+			if (value.Length < 256)
+			{
+				var valueLength = unchecked((int)value.Length);
+				var maxByteLength = encoding.GetMaxByteCount(valueLength);
+
+				if (maxByteLength < 32)
+				{
+					// stack alloc is fastest
+					Span<byte> encodingBuffer = stackalloc byte[maxByteLength];
+					var actualLength = encoding.GetBytes(value, encodingBuffer);
+					var sink = buffer.GetSpan(actualLength + 1);
+					sink[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | actualLength));
+					encodingBuffer.Slice(actualLength).CopyTo(sink.Slice(1));
+					buffer.Advance(sink.Length);
+					return;
+				}
+				else if (maxByteLength < 256)
+				{
+					// stack alloc is fastest
+					Span<byte> encodingBuffer = stackalloc byte[maxByteLength + 3];
+					var actualLength = encoding.GetBytes(value, encodingBuffer);
+					var sink = buffer.GetSpan(3);
+					var headerLength = this.EncodeStringHeader(unchecked((uint)actualLength), sink);
+					buffer.Advance(headerLength);
+					encodingBuffer.Slice(0, actualLength).CopyTo(buffer.GetSpan(actualLength));
+					buffer.Advance(actualLength);
+					return;
+				}
+			}
+
+			this.EncodeStringSlow(value, buffer, encoding);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private void EncodeStringSlow(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			// Use 1-path logic borrowed from MessagePack C#
+
+			// Get max char bytes. Use 2 for 0 (maybe bug) or 1 (ASCII) to simplify following logic.
+			var maxBytesPerChar = Math.Max(encoding.GetMaxByteCount(1), 2);
+
+			// In most case, msgpack uses UTF-8 and clob contains 1 to 3 byte chars,
+			// and may charactors are ASCII.
+			// So, estimate with 1char is 2bytes is good enough here.
+			var estimatedLength = unchecked((uint)value.Length * 2);
+			var bufferLength = encoding.GetMaxByteCount(unchecked((int)value.Length)) + 5;
+
+			if (bufferLength <= 0x20_0000) // 2MB
+			{
+				Memory<byte> sinkMemory = buffer.GetMemory(bufferLength);
+
+				if (MemoryMarshal.TryGetArray<byte>(sinkMemory, out var sinkBufferSegment))
+				{
+					// We can get single array
+					buffer.Advance(this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, sinkBufferSegment));
+				}
+				else
+				{
+					// Memory is not array backend, so use local buffer.
+					var encodingBuffer = base.Options.ByteBufferPool.Rent(bufferLength);
+					try
+					{
+						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
+						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
+					}
+					finally
+					{
+						base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
+					}
+				}
+			}
+
+			this.EncodeHugeString2Path(value, buffer, encoding);
+		}
+
+		
+		private unsafe int EncodeLargeString1Path(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding encoding, uint estimatedLength, ArraySegment<byte> sinkBufferSegment)
+		{
+			ref var head = ref sinkBufferSegment.Array![sinkBufferSegment.Offset];
+
+			Span<byte> sinkBuffer = sinkBufferSegment;
+			var estimatedHeaderLength = this.EncodeStringHeader(estimatedLength, sinkBuffer);
+
+			int actualLength;
+
+			try
+			{
+				actualLength = encoding.GetBytes(value, sinkBuffer.Slice(estimatedHeaderLength));
+			}
+			catch (OverflowException ex)
+			{
+				Throw.TooLargeByteLength(ex, encoding.EncodingName);
+				return 0;
+			}
+
+			var realHeaderLength = this.EncodeStringHeader(unchecked((uint)actualLength), sinkBuffer);
+
+			if (estimatedHeaderLength != realHeaderLength)
+			{
+				fixed (byte* pSinkBuffer = &head)
+				{
+					Buffer.MemoryCopy((void*)(pSinkBuffer + estimatedHeaderLength), (void*)(pSinkBuffer + realHeaderLength), actualLength, actualLength);
+				}
+			}
+
+			return actualLength + realHeaderLength;
+		}
+
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt
new file mode 100644
index 000000000..7f8eb2206
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt
@@ -0,0 +1,173 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	partial class MessagePackEncoder
+	{
+<#
+foreach (var inputType in
+	new []
+	{
+		new { Signature = "ReadOnlySpan",			MayBe64BitLength = false },
+		new { Signature = "in ReadOnlySequence" ,	MayBe64BitLength = true },
+	}
+)
+{
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeString(<#= inputType.Signature #><char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			buffer = EnsureNotNull(buffer);
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+<#
+	if (inputType.MayBe64BitLength)
+	{
+#>
+			if (value.Length > UInt32.MaxValue)
+			{
+				Throw.TooLargeCharLength(value.Length);
+				return;
+			}
+
+<#
+	}
+#>
+			if (value.Length == 0)
+			{
+				buffer.GetSpan(1)[0] = MessagePackCode.MinimumFixedRaw;
+				buffer.Advance(1);
+				return;
+			}
+
+			if (value.Length < 256)
+			{
+				var valueLength = unchecked((int)value.Length);
+				var maxByteLength = encoding.GetMaxByteCount(valueLength);
+
+				if (maxByteLength < 32)
+				{
+					// stack alloc is fastest
+					Span<byte> encodingBuffer = stackalloc byte[maxByteLength];
+					var actualLength = encoding.GetBytes(value, encodingBuffer);
+					var sink = buffer.GetSpan(actualLength + 1);
+					sink[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | actualLength));
+					encodingBuffer.Slice(actualLength).CopyTo(sink.Slice(1));
+					buffer.Advance(sink.Length);
+					return;
+				}
+				else if (maxByteLength < 256)
+				{
+					// stack alloc is fastest
+					Span<byte> encodingBuffer = stackalloc byte[maxByteLength + 3];
+					var actualLength = encoding.GetBytes(value, encodingBuffer);
+					var sink = buffer.GetSpan(3);
+					var headerLength = this.EncodeStringHeader(unchecked((uint)actualLength), sink);
+					buffer.Advance(headerLength);
+					encodingBuffer.Slice(0, actualLength).CopyTo(buffer.GetSpan(actualLength));
+					buffer.Advance(actualLength);
+					return;
+				}
+			}
+
+			this.EncodeStringSlow(value, buffer, encoding);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private void EncodeStringSlow(<#= inputType.Signature #><char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			// Use 1-path logic borrowed from MessagePack C#
+
+			// Get max char bytes. Use 2 for 0 (maybe bug) or 1 (ASCII) to simplify following logic.
+			var maxBytesPerChar = Math.Max(encoding.GetMaxByteCount(1), 2);
+
+			// In most case, msgpack uses UTF-8 and clob contains 1 to 3 byte chars,
+			// and may charactors are ASCII.
+			// So, estimate with 1char is 2bytes is good enough here.
+			var estimatedLength = unchecked((uint)value.Length * 2);
+			var bufferLength = encoding.GetMaxByteCount(unchecked((int)value.Length)) + 5;
+
+			if (bufferLength <= 0x20_0000) // 2MB
+			{
+				Memory<byte> sinkMemory = buffer.GetMemory(bufferLength);
+
+				if (MemoryMarshal.TryGetArray<byte>(sinkMemory, out var sinkBufferSegment))
+				{
+					// We can get single array
+					buffer.Advance(this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, sinkBufferSegment));
+				}
+				else
+				{
+					// Memory is not array backend, so use local buffer.
+					var encodingBuffer = base.Options.ByteBufferPool.Rent(bufferLength);
+					try
+					{
+						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
+						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
+					}
+					finally
+					{
+						base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
+					}
+				}
+			}
+
+			this.EncodeHugeString2Path(value, buffer, encoding);
+		}
+
+		
+		private unsafe int EncodeLargeString1Path(<#= inputType.Signature #><char> value, IBufferWriter<byte> buffer, Encoding encoding, uint estimatedLength, ArraySegment<byte> sinkBufferSegment)
+		{
+			ref var head = ref sinkBufferSegment.Array![sinkBufferSegment.Offset];
+
+			Span<byte> sinkBuffer = sinkBufferSegment;
+			var estimatedHeaderLength = this.EncodeStringHeader(estimatedLength, sinkBuffer);
+
+			int actualLength;
+
+			try
+			{
+				actualLength = encoding.GetBytes(value, sinkBuffer.Slice(estimatedHeaderLength));
+			}
+			catch (OverflowException ex)
+			{
+				Throw.TooLargeByteLength(ex, encoding.EncodingName);
+				return 0;
+			}
+
+			var realHeaderLength = this.EncodeStringHeader(unchecked((uint)actualLength), sinkBuffer);
+
+			if (estimatedHeaderLength != realHeaderLength)
+			{
+				fixed (byte* pSinkBuffer = &head)
+				{
+					Buffer.MemoryCopy((void*)(pSinkBuffer + estimatedHeaderLength), (void*)(pSinkBuffer + realHeaderLength), actualLength, actualLength);
+				}
+			}
+
+			return actualLength + realHeaderLength;
+		}
+
+<#
+}
+#>
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
new file mode 100644
index 000000000..9e9023ac9
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
@@ -0,0 +1,249 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Common encoder implementation between legacy and current MessagePack format enconders.
+	/// </summary>
+	public abstract partial class MessagePackEncoder : Encoder
+	{
+#warning TODO: Can devirt?
+		public static MessagePackEncoder CreateLegacy(MessagePackEncoderOptions options) => new LegacyMessagePackEncoder(options);
+		public static MessagePackEncoder CreateCurrent(MessagePackEncoderOptions options) => new CurrentMessagePackEncoder(options);
+
+		public new MessagePackEncoderOptions Options => (base.Options as MessagePackEncoderOptions)!;
+
+		protected MessagePackEncoder(MessagePackEncoderOptions options)
+			: base(options) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeSingle(float value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var span = buffer.GetSpan(sizeof(float) + 1);
+
+			span[0] = MessagePackCode.Real32;
+			span = span.Slice(1);
+			BinaryPrimitives.WriteInt32BigEndian(span, BitConverter.SingleToInt32Bits(value));
+			buffer.Advance(sizeof(float) + 1);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeDouble(double value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var span = buffer.GetSpan(sizeof(double) + 1);
+
+			span[0] = MessagePackCode.Real64;
+			span = span.Slice(1);
+			BinaryPrimitives.WriteInt64BigEndian(span, BitConverter.DoubleToInt64Bits(value));
+			buffer.Advance(sizeof(double) + 1);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeBoolean(bool value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var span = buffer.GetSpan(1);
+			span[0] = unchecked((byte)(value ? MessagePackCode.TrueValue : MessagePackCode.FalseValue));
+			buffer.Advance(1);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeArrayStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		{
+			buffer = EnsureNotNull(buffer);
+			collectionContext.IncrementDepth();
+
+			if (length < 16)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(MessagePackCode.MinimumFixedArray | length));
+				buffer.Advance(1);
+			}
+			else if (length < 16)
+			{
+				var span = buffer.GetSpan(sizeof(ushort) + 1);
+				span[0] = MessagePackCode.Array16;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteUInt16BigEndian(span, unchecked((ushort)length));
+				buffer.Advance(sizeof(ushort) + 1);
+			}
+			else
+			{
+				var span = buffer.GetSpan(sizeof(uint) + 1);
+				span[0] = MessagePackCode.Array32;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteInt32BigEndian(span, length);
+				buffer.Advance(sizeof(uint) + 1);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeArrayEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeArrayItemStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeArrayItemEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeMapStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			if (length < 16)
+			{
+				var span = buffer.GetSpan(1);
+				span[0] = unchecked((byte)(MessagePackCode.MinimumFixedMap | length));
+				buffer.Advance(1);
+			}
+			else if (length < 16)
+			{
+				var span = buffer.GetSpan(sizeof(ushort) + 1);
+				span[0] = MessagePackCode.Map16;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteUInt16BigEndian(span, unchecked((ushort)length));
+				buffer.Advance(sizeof(ushort) + 1);
+			}
+			else
+			{
+				var span = buffer.GetSpan(sizeof(uint) + 1);
+				span[0] = MessagePackCode.Map32;
+				span = span.Slice(1);
+				BinaryPrimitives.WriteInt32BigEndian(span, length);
+				buffer.Advance(sizeof(uint) + 1);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeMapEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeMapKeyStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeMapKeyEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeMapValueStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeNull(IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var span = buffer.GetSpan(1);
+			span[0] = MessagePackCode.NilValue;
+			buffer.Advance(1);
+		}
+
+		private void EncodeHugeString2Path(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			// Huge path, we cannot use rollback because it requires multiple span from buffer.
+			int actualLength;
+			try
+			{
+				actualLength = encoding.GetByteCount(value);
+			}
+			catch(OverflowException ex)
+			{
+				Throw.TooLargeByteLength(ex, encoding.EncodingName);
+				return;
+			}
+
+			var span = buffer.GetSpan(5);
+			var headerLength = this.EncodeStringHeader(unchecked((uint)actualLength), span);
+			buffer.Advance(headerLength);
+			encoding.GetBytes(value, buffer);
+		}
+
+		private void EncodeHugeString2Path(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			// Huge path, we cannot use rollback because it requires multiple span from buffer.
+			var actualLength = 0L;
+			var reader = new SequenceReader<char>(value);
+			while (!reader.End)
+			{
+				actualLength += encoding.GetByteCount(reader.UnreadSpan);
+				reader.Advance(reader.UnreadSpan.Length);
+			}
+
+			if (actualLength > UInt32.MaxValue)
+			{
+				Throw.TooLargeByteLength(actualLength, encoding.EncodingName);
+			}
+
+			var span = buffer.GetSpan(5);
+			var headerLength = this.EncodeStringHeader(unchecked((uint)actualLength), span);
+			buffer.Advance(headerLength);
+			encoding.GetBytes(value, buffer);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			buffer = EnsureNotNull(buffer);
+			
+			var span = buffer.GetSpan(5);
+			var used = this.EncodeStringHeader(unchecked((uint)encodedValue.Length), span);
+			buffer.Advance(used);
+			this.WriteRaw(encodedValue, buffer, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private void EncodeStringHeader(uint length, Memory<byte> memory)
+			=> this.EncodeStringHeader(length, memory.Span);
+
+		protected abstract int EncodeStringHeader(uint length, Span<byte> buffer);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			var span = buffer.GetSpan(5);
+			var used = this.EncodeStringHeader(unchecked((uint)encodedValue.Length), span);
+			buffer.Advance(used);
+			this.WriteRaw(encodedValue, buffer, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			var span = buffer.GetSpan(5);
+			var used = this.EncodeBinaryHeader(unchecked((uint)value.Length), span);
+			buffer.Advance(used);
+			this.WriteRaw(value, buffer, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken)
+		{
+			var span = buffer.GetSpan(5);
+			var used = this.EncodeBinaryHeader(unchecked((uint)value.Length), span);
+			buffer.Advance(used);
+			this.WriteRaw(value, buffer, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private int EncodeBinaryHeader(uint length, Memory<byte> memory)
+			=> this.EncodeBinaryHeader(length, memory.Span);
+
+		protected abstract int EncodeBinaryHeader(uint length, Span<byte> buffer);
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs b/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
new file mode 100644
index 000000000..ad3efa2cf
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
@@ -0,0 +1,11 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	public sealed class MessagePackEncoderOptions : EncoderOptions
+	{
+		public MessagePackEncoderOptions(MessagePackEncoderOptionsBuilder builder) : base(builder) { }
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs b/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs
new file mode 100644
index 000000000..0f343c3c2
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs
@@ -0,0 +1,13 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	public sealed class MessagePackEncoderOptionsBuilder : EncoderOptionsBuilder
+	{
+		public MessagePackEncoderOptionsBuilder() { }
+
+		public MessagePackEncoderOptions Build() => new MessagePackEncoderOptions(this);
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MessagePackThrow.cs b/src/MsgPack.Core/Internal/MessagePackThrow.cs
new file mode 100644
index 000000000..c9c18f9b4
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackThrow.cs
@@ -0,0 +1,45 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache 2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal static class MessagePackThrow
+	{
+		public static void IsNotType(byte header, long position, Type requestType)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but {requestType} is required at {position:#,0}.");
+
+		public static void RealCannotBeInteger(byte header, long position, Type requestType)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) is not compatible for {requestType} in current configuration at {position:#,0}.");
+
+		public static void TypeIsNotArray(byte header, long position)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but array is required at {position:#,0}.");
+
+		public static void TypeIsNotMap(byte header, long position)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but map is required at {position:#,0}.");
+
+		public static void TypeIsNotArrayNorMap(byte header, long position)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but array or map is required at {position:#,0}.");
+
+		public static void IsNotNumber(byte header, long position, Type requestType)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but it is not compatible for {requestType} at {position:#,0}.");
+
+		public static void TooLargeByteLength(byte header, long position, long byteLength)
+			=> throw new MessageTypeException($"The length of string {MessagePackCode.ToString(header)}(0x{header:X2}) {byteLength:#,0}(0x{byteLength:X8}) exceeds Int32.MaxValue (0x7FFFFFFF) at {position:#,0}.");
+
+		public static void TooLargeArrayOrMapLength(byte header, long position, long byteLength)
+			=> throw new MessageTypeException($"The length of array or map {MessagePackCode.ToString(header)}(0x{header:X2}) {byteLength:#,0}(0x{byteLength:X8}) exceeds Int32.MaxValue (0x7FFFFFFF) at {position:#,0}.");
+
+		public static void OutOfRangeExtensionTypeCode(int typeCode, [CallerArgumentExpression("typeCode")] string? paramName = default)
+			=> throw new ArgumentOutOfRangeException(paramName, $"A type code of MessagePack must be non negative 1byte integer (between 0 to 127 inclusive). '{typeCode}' is too large.");
+
+		public static void IsNotUtf8String(byte header, long position)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but it is not compatible for UTF8String at {position:#,0}.");
+
+		public static void IsNotExtension(byte header, long position)
+			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but it is not extension at {position:#,0}.");
+	}
+}
diff --git a/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs b/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs
new file mode 100644
index 000000000..93ef16a78
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs
@@ -0,0 +1,299 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers.Binary;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace MsgPack.Internal
+{
+	// Basic idea is borrwed from AutomataDictionary of Message Pack C#
+	// https://github.com/neuecc/MessagePack-CSharp/blob/51649e0d7b8641ad5d3cdd6dfdc130c7671066fc/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Internal/AutomataDictionary.cs#L1
+
+	public sealed class MsgPackStringTrie<T>
+	{
+		private readonly T _default;
+		private readonly Node _root;
+
+		public MsgPackStringTrie(T defaultValue)
+		{
+			this._default = defaultValue;
+			this._root = new Node(defaultValue, Array.Empty<Node>(), Array.Empty<ulong>());
+		}
+
+		public bool TryAdd(ReadOnlySpan<byte> utf8Key, T value)
+			=> this.TryAdd(this._root, GenerateKeyHead(ref utf8Key), utf8Key, value);
+
+		private static int BinarySearch(ulong[] nodes, ulong key)
+		{
+			// Span<T>.BinarySearch is slower maybe because of ComapreTo method overhead, so we implement binary search manually.
+			var low = 0;
+			var high = nodes.Length - 1;
+			while (low <= high)
+			{
+				// Peformance trick borrowed from https://github.com/dotnet/runtime/blob/f2786223508c0c70040fbf48ec3a39a607dd7f75/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.BinarySearch.cs#L42
+				var index = unchecked((int)(((uint)high + (uint)low) >> 1));
+				var found = nodes[index];
+				if (found == key)
+				{
+					return index;
+				}
+				else if (found < key)
+				{
+					low = index + 1;
+				}
+				else
+				{
+					high = index - 1;
+				}
+			}
+
+			return ~low;
+		}
+
+		public T GetOrDefault(ReadOnlySpan<byte> msgPackStringKey)
+		{
+			var result = this.Find(this._root, GenerateKeyRest(ref msgPackStringKey), msgPackStringKey);
+			return result != null ? result.Value : this._default;
+		}
+
+		private bool TryAdd(Node parent, ulong key, ReadOnlySpan<byte> trailingKey, T value)
+		{
+			var nodes = parent.ChildNodes;
+			var keys = parent.ChildKeys;
+
+			while (true)
+			{
+				var index = BinarySearch(keys, key);
+
+				if (index < 0)
+				{
+					// No matching leaf.
+					this.AddNode(parent, key, trailingKey, ~index, value, out _);
+					return true;
+				}
+
+				var found = nodes[index];
+				if (trailingKey.IsEmpty)
+				{
+					// The leaf matches.
+					return false;
+				}
+
+				if (found.ChildNodes.Length == 0)
+				{
+					// Search key is longer than trie path.
+					this.AddNode(found, key, trailingKey, 0, value, out _);
+					return true;
+				}
+
+				nodes = found.ChildNodes;
+				keys = found.ChildKeys;
+
+				key = GenerateKeyRest(ref trailingKey);
+			}
+		}
+
+		private Node? Find(Node parent, ulong key, ReadOnlySpan<byte> trailingKey)
+		{
+			var nodes = parent.ChildNodes;
+			var keys = parent.ChildKeys;
+
+			while (true)
+			{
+				var index = BinarySearch(keys, key);
+
+				if (index < 0)
+				{
+					// No matching leaf.
+					return null;
+				}
+
+				var found = nodes[index];
+				if (trailingKey.IsEmpty)
+				{
+					// The leaf matches.
+					return found;
+				}
+
+				if (found.ChildNodes.Length == 0)
+				{
+					// Search key is longer than trie path.
+					return null;
+				}
+
+				nodes = found.ChildNodes;
+				keys = found.ChildKeys;
+				key = GenerateKeyRest(ref trailingKey);
+			}
+		}
+
+		private void AddNode(Node node, ulong key, ReadOnlySpan<byte> trailingKey, int targetIndex, T value, out Node result)
+		{
+			Array.Resize(ref node.ChildKeys, node.ChildKeys.Length + 1);
+			Array.Resize(ref node.ChildNodes, node.ChildNodes.Length + 1);
+			var nodes = node.ChildNodes;
+			var keys = node.ChildKeys;
+
+			while (true)
+			{
+				var child =
+					trailingKey.IsEmpty ?
+						new Node(value, Array.Empty<Node>(), Array.Empty<ulong>()) :
+						new Node(this._default, new Node[1], new ulong[1]);
+
+				if (nodes.Length > 1 && targetIndex < nodes.Length - 1)
+				{
+					// Shift existing.
+					Array.Copy(nodes, targetIndex, nodes, targetIndex + 1, nodes.Length - targetIndex - 1);
+					Array.Copy(keys, targetIndex, keys, targetIndex + 1, keys.Length - targetIndex - 1);
+				}
+
+				nodes[targetIndex] = child;
+				keys[targetIndex] = key;
+
+				if (trailingKey.IsEmpty)
+				{
+					// This is leaf.
+					result = child;
+					return;
+				}
+
+				nodes = child.ChildNodes;
+				keys = child.ChildKeys;
+
+				Debug.Assert(nodes.Length == 1);
+				Debug.Assert(keys.Length == 1);
+				targetIndex = 0;
+
+				key = GenerateKeyRest(ref trailingKey);
+			}
+		}
+
+		private static ulong GenerateKeyHead(ref ReadOnlySpan<byte> source)
+		{
+			Span<byte> bytes = stackalloc byte[sizeof(ulong)];
+			var buffer = bytes;
+			int consumes;
+			if (source.Length < 16)
+			{
+				buffer[0] = (byte)(0xA0 | source.Length);
+				buffer = buffer.Slice(1);
+				consumes = Math.Min(source.Length, sizeof(long) - 1);
+			}
+			else if (source.Length <= Byte.MaxValue)
+			{
+				buffer[0] = 0xD9;
+				buffer[1] = (byte)source.Length;
+				buffer = buffer.Slice(2);
+				consumes = Math.Min(source.Length, sizeof(long) - 1 - 1);
+			}
+			else if (source.Length <= UInt16.MaxValue)
+			{
+				buffer[0] = 0xDA;
+				buffer = buffer.Slice(1);
+				BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)source.Length);
+				buffer = buffer.Slice(sizeof(ushort));
+				consumes = Math.Min(source.Length, sizeof(long) - 1 - sizeof(ushort));
+			}
+			else
+			{
+				buffer[0] = 0xDB;
+				buffer = buffer.Slice(1);
+				BinaryPrimitives.WriteInt32BigEndian(buffer, source.Length);
+				buffer = buffer.Slice(sizeof(int));
+				consumes = Math.Min(source.Length, sizeof(long) - 1 - sizeof(int));
+			}
+
+			source.Slice(0, consumes).CopyTo(buffer);
+			source = source.Slice(consumes);
+			return MemoryMarshal.Cast<byte, ulong>(bytes)[0];
+		}
+
+		private static ulong GenerateKeyRest(ref ReadOnlySpan<byte> source)
+		{
+			Debug.Assert(!source.IsEmpty);
+			if (source.Length >= sizeof(ulong))
+			{
+				var result = MemoryMarshal.Cast<byte, ulong>(source)[0];
+				source = source.Slice(sizeof(ulong));
+				return result;
+			}
+			else
+			{
+				ulong result;
+				unchecked
+				{
+					switch (source.Length)
+					{
+						case 1:
+						{
+							result = source[0];
+							break;
+						}
+						case 2:
+						{
+							result = BinaryPrimitives.ReadUInt16LittleEndian(source);
+							break;
+						}
+						case 3:
+						{
+							result = BinaryPrimitives.ReadUInt16LittleEndian(source);
+							source = source.Slice(2);
+							result |= (uint)(source[0] << 16);
+							break;
+						}
+						case 4:
+						{
+							result = BinaryPrimitives.ReadUInt32LittleEndian(source);
+							break;
+						}
+						case 5:
+						{
+							result = BinaryPrimitives.ReadUInt32LittleEndian(source);
+							source = source.Slice(4);
+							result |= ((ulong)source[0] << 32);
+							break;
+						}
+						case 6:
+						{
+							result = BinaryPrimitives.ReadUInt32LittleEndian(source);
+							source = source.Slice(4);
+							result |= ((ulong)BinaryPrimitives.ReadUInt16LittleEndian(source) << 32);
+							break;
+						}
+						default: // 7
+						{
+							result = BinaryPrimitives.ReadUInt32LittleEndian(source);
+							source = source.Slice(4);
+							result |= ((ulong)BinaryPrimitives.ReadUInt16LittleEndian(source) << 32);
+							source = source.Slice(2);
+							result |= ((ulong)source[0] << 48);
+							break;
+						}
+					}
+				}
+
+				source = ReadOnlySpan<byte>.Empty;
+				return result;
+			}
+		}
+
+		private sealed class Node
+		{
+			// There 2 separate array to improve search performance due to CPU cache line and prediction.
+			public ulong[] ChildKeys;
+			public Node[] ChildNodes;
+			public readonly T Value;
+
+			public Node(T value, Node[] childNodes, ulong[] childKeys)
+			{
+				this.Value = value;
+				this.ChildNodes = childNodes;
+				this.ChildKeys = childKeys;
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Core/MsgPack.Core.csproj b/src/MsgPack.Core/MsgPack.Core.csproj
new file mode 100644
index 000000000..e04106cd6
--- /dev/null
+++ b/src/MsgPack.Core/MsgPack.Core.csproj
@@ -0,0 +1,71 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../MsgPack.Abstraction/MsgPack.Abstraction.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="../MsgPack/MessagePackCode.cs" Link="MessagePackCode.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Internal\MessagePackDecoder.Integers.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>MessagePackDecoder.Integers.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Internal\MessagePackDecoder.Nullables.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>MessagePackDecoder.Nullables.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Internal\MessagePackDecoder.Reals.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>MessagePackDecoder.Reals.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Internal\MessagePackEncoder.Integers.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>MessagePackEncoder.Integers.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Internal\MessagePackEncoder.Strings.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>MessagePackEncoder.Strings.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Internal/MessagePackDecoder.Nullables.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>MessagePackDecoder.Nullables.cs</LastGenOutput>
+    </None>
+    <None Update="Internal/MessagePackDecoder.Reals.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>MessagePackDecoder.Reals.cs</LastGenOutput>
+    </None>
+    <None Update="Internal/MessagePackEncoder.Integers.tt">
+      <LastGenOutput>MessagePackEncoder.Integers.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Internal/MessagePackDecoder.Integers.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>MessagePackDecoder.Integers.cs</LastGenOutput>
+    </None>
+    <None Update="Internal/MessagePackEncoder.Strings.tt">
+      <LastGenOutput>MessagePackEncoder.Strings.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/MsgPack.Core/System.Text/EncodingExtensions.cs b/src/MsgPack.Core/System.Text/EncodingExtensions.cs
index 9cc34cbd3..09f42c63d 100644
--- a/src/MsgPack.Core/System.Text/EncodingExtensions.cs
+++ b/src/MsgPack.Core/System.Text/EncodingExtensions.cs
@@ -13,6 +13,7 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 using MsgPack.Internal;
 
 namespace System.Text
@@ -141,7 +142,7 @@ public static int GetBytes(this Encoding encoding, in ReadOnlySequence<char> cha
 
 				ReadOnlySequence<char> remainingChars = chars;
 				int originalBytesLength = bytes.Length;
-				Encoder encoder = encoding.GetEncoder();
+				var encoder = encoding.GetEncoder();
 				bool isFinalSegment;
 
 				do
@@ -188,7 +189,7 @@ public static byte[] GetBytes(this Encoding encoding, in ReadOnlySequence<char>
 				// If the incoming sequence is multi-segment, create a stateful Encoder
 				// and use it as the workhorse. On the final iteration we'll pass flush=true.
 
-				Encoder encoder = encoding.GetEncoder();
+				var encoder = encoding.GetEncoder();
 
 				// Maintain a list of all the segments we'll need to concat together.
 				// These will be released back to the pool at the end of the method.
@@ -352,7 +353,7 @@ public static int GetChars(this Encoding encoding, in ReadOnlySequence<byte> byt
 
 				ReadOnlySequence<byte> remainingBytes = bytes;
 				int originalCharsLength = chars.Length;
-				Decoder decoder = encoding.GetDecoder();
+				var decoder = encoding.GetDecoder();
 				bool isFinalSegment;
 
 				do
@@ -392,59 +393,68 @@ public static string GetString(this Encoding encoding, in ReadOnlySequence<byte>
 			}
 			else
 			{
-				// If the incoming sequence is multi-segment, create a stateful Decoder
-				// and use it as the workhorse. On the final iteration we'll pass flush=true.
+				return encoding.GetStringMultiSegment(bytes, ArrayPool<char>.Shared);
+			}
+		}
 
-				Decoder decoder = encoding.GetDecoder();
+		internal static string GetStringMultiSegment(this Encoding encoding, in ReadOnlySequence<byte> bytes, ArrayPool<char> arrayPool, CancellationToken cancellationToken = default)
+		{
+			// If the incoming sequence is multi-segment, create a stateful Decoder
+			// and use it as the workhorse. On the final iteration we'll pass flush=true.
 
-				// Maintain a list of all the segments we'll need to concat together.
-				// These will be released back to the pool at the end of the method.
+			var decoder = encoding.GetDecoder();
 
-				List<(char[], int)> listOfSegments = new List<(char[], int)>();
-				int totalCharCount = 0;
+			// Maintain a list of all the segments we'll need to concat together.
+			// These will be released back to the pool at the end of the method.
 
-				ReadOnlySequence<byte> remainingBytes = bytes;
-				bool isFinalSegment;
+			List<(char[], int)> listOfSegments = new List<(char[], int)>();
+			int totalCharCount = 0;
 
-				do
-				{
-					GetFirstSpan(remainingBytes, out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
-					isFinalSegment = remainingBytes.IsSingleSegment;
+			ReadOnlySequence<byte> remainingBytes = bytes;
+			bool isFinalSegment;
+
+			do
+			{
+				GetFirstSpan(remainingBytes, out ReadOnlySpan<byte> firstSpan, out SequencePosition next);
+				isFinalSegment = remainingBytes.IsSingleSegment;
 
-					int charCountThisIteration = decoder.GetCharCount(firstSpan, flush: isFinalSegment); // could throw ArgumentException if overflow would occur
-					char[] rentedArray = ArrayPool<char>.Shared.Rent(charCountThisIteration);
-					int actualCharsWrittenThisIteration = decoder.GetChars(firstSpan, rentedArray, flush: isFinalSegment);
-					listOfSegments.Add((rentedArray, actualCharsWrittenThisIteration));
+				int charCountThisIteration = decoder.GetCharCount(firstSpan, flush: isFinalSegment); // could throw ArgumentException if overflow would occur
+				char[] rentedArray = arrayPool.Rent(charCountThisIteration);
+				int actualCharsWrittenThisIteration = decoder.GetChars(firstSpan, rentedArray, flush: isFinalSegment);
+				listOfSegments.Add((rentedArray, actualCharsWrittenThisIteration));
 
-					totalCharCount += actualCharsWrittenThisIteration;
-					if (totalCharCount < 0)
+				totalCharCount += actualCharsWrittenThisIteration;
+				if (totalCharCount < 0)
+				{
+					foreach(var segment in listOfSegments)
 					{
-						// If we overflowed, call string.Create, passing int.MaxValue.
-						// This will end up throwing the expected OutOfMemoryException
-						// since strings are limited to under int.MaxValue elements in length.
-
-						totalCharCount = Int32.MaxValue;
-						break;
+						arrayPool.Return(segment.Item1);
 					}
 
-					remainingBytes = remainingBytes.Slice(next);
-				} while (!isFinalSegment);
+					// overflow
+					Throw.TooLargeByteLengthForString(encoding.EncodingName);
+					// never reaches.
+					return null!;
+				}
 
-				// Now build up the string to return, then release all of our scratch buffers
-				// back to the shared pool.
+				remainingBytes = remainingBytes.Slice(next);
+				cancellationToken.ThrowIfCancellationRequested();
+			} while (!isFinalSegment);
 
-				return String.Create(totalCharCount, listOfSegments, (span, listOfSegments) =>
+			// Now build up the string to return, then release all of our scratch buffers
+			// back to the shared pool.
+
+			return String.Create(totalCharCount, listOfSegments, (span, listOfSegments) =>
+			{
+				foreach ((char[] array, int length) in listOfSegments)
 				{
-					foreach ((char[] array, int length) in listOfSegments)
-					{
-						array.AsSpan(0, length).CopyTo(span);
-						ArrayPool<char>.Shared.Return(array);
-						span = span.Slice(length);
-					}
+					array.AsSpan(0, length).CopyTo(span);
+					arrayPool.Return(array);
+					span = span.Slice(length);
+				}
 
-					Debug.Assert(span.IsEmpty, "Over-allocated the string instance?");
-				});
-			}
+				Debug.Assert(span.IsEmpty, "Over-allocated the string instance?");
+			});
 		}
 
 		/// <summary>
diff --git a/src/MsgPack.Core/_SampleObject.cs b/src/MsgPack.Core/_SampleObject.cs
new file mode 100644
index 000000000..9c6e63c35
--- /dev/null
+++ b/src/MsgPack.Core/_SampleObject.cs
@@ -0,0 +1,1085 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading.Tasks;
+using MsgPack.Serialization.Internal;
+
+namespace MsgPack.Internal
+{
+	internal sealed class SampleObject
+	{
+		public int Age { get; set; }
+		public string Name { get; set; }
+		public bool IsActive { get; set; }
+		public IDictionary<string, string> Attributes { get; } = new Dictionary<string, string>();
+		public IList<string> Roles { get; } = new List<string>();
+	}
+
+	// MP.Core.Abstraction
+	// MP.Core / MP.Json.Core / MP.Yaml.Core / MP.Coff.Core
+	// MP.Serialization.Core -> Interfaces, ....
+	// MP.Serialization -> Basic serializers, context, utilities, Stream adapter, byte[] adapter, etc.
+	// MP.Serialization.Serializers-> Extended serializers implementation.
+	// MP.Serialization.Reflection -> Reflection
+	// MP.Serialization.ILGeneration -> Reflection
+	// MP.Serialization.SourceGeneration -> Reflection
+	// MP.Extensions  / MP.Json.Extensions / MP.Yaml.Extensions / MP.Coff.Extensions -> MPO, DOM, etc
+	// MP.Compatibility1 -> v1 compatibility shims
+	// MP.Cli -> v1 compatibility shims
+
+	// Packer/Unpacker compatibility note:
+	// Packer -> Packer.Create(new MemoryStream())
+	// Unpacker -> Unpacker.Create(new MemoryStream())???
+
+	// For PoC of MVP and reference for emit.
+	/// <summary>
+	///		Sample hand made serializer.
+	/// </summary>
+	internal sealed class SampleSerializer : IObjectSerializer<SampleObject>
+	{
+		private bool UseArray { get; set; }
+
+		public void Serialize(in SerializationOperationContext context, SampleObject obj, IBufferWriter<byte> writer)
+		{
+			var encoder = context.Encoder;
+			if (obj == null)
+			{
+				encoder.EncodeNull(writer);
+				return;
+			}
+
+			if (this.UseArray)
+			{
+				encoder.EncodeArrayStart(5, writer, context.CollectionContext); // OMITTABLE
+				encoder.EncodeString(obj.Name, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+				encoder.EncodeInt32(obj.Age, writer);
+				encoder.EncodeBoolean(obj.IsActive, writer);
+				if (obj.Attributes == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeMapStart(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
+					var i = 0; // OMITTABLE
+					foreach (var entry in obj.Attributes)
+					{
+						encoder.EncodeMapKeyStart(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeString(entry.Key, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+						encoder.EncodeMapKeyEnd(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeMapValueStart(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeString(entry.Value, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+						encoder.EncodeMapValueEnd(i, writer, context.CollectionContext); // OMITTABLE
+					}
+					encoder.EncodeMapEnd(obj.Attributes.Count, writer, context.CollectionContext);
+				}
+				if (obj.Roles == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeArrayStart(obj.Roles.Count, writer, context.CollectionContext); // OMITTABLE
+					var i = 0; // OMITTABLE
+					foreach (var item in obj.Roles)
+					{
+						encoder.EncodeArrayItemStart(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeString(item, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+						encoder.EncodeArrayItemEnd(i, writer, context.CollectionContext); // OMITTABLE
+					}
+					encoder.EncodeArrayEnd(obj.Roles.Count, writer, context.CollectionContext);
+				}
+				encoder.EncodeArrayEnd(5, writer, context.CollectionContext); // OMITTABLE
+			}
+			else
+			{
+				encoder.EncodeMapStart(5, writer, context.CollectionContext); // OMITTABLE
+				ReadOnlySpan<byte> key0 = new[] { (byte)'N', (byte)'a', (byte)'m', (byte)'e' }; // static readonly
+				encoder.EncodeString(key0, 4, writer, context.CancellationToken);
+				encoder.EncodeString(obj.Name, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+				ReadOnlySpan<byte> key1 = new[] { (byte)'A', (byte)'g', (byte)'e' }; // static readonly
+				encoder.EncodeString(key1, 3, writer, context.CancellationToken);
+				encoder.EncodeInt32(obj.Age, writer);
+				ReadOnlySpan<byte> key2 = new[] { (byte)'I', (byte)'s', (byte)'a', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e' }; // static readonly
+				encoder.EncodeString(key2, 8, writer, context.CancellationToken);
+				encoder.EncodeBoolean(obj.IsActive, writer);
+				ReadOnlySpan<byte> key3 = new[] { (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s' }; // static readonly
+				encoder.EncodeString(key3, 10, writer, context.CancellationToken);
+				if (obj.Attributes == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeMapStart(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
+					var i = 0; // OMITTABLE
+					foreach (var entry in obj.Attributes)
+					{
+						encoder.EncodeMapKeyStart(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeString(entry.Key, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+						encoder.EncodeMapKeyEnd(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeMapValueStart(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeString(entry.Value, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+						encoder.EncodeMapValueEnd(i, writer, context.CollectionContext); // OMITTABLE
+					}
+					encoder.EncodeMapEnd(obj.Attributes.Count, writer, context.CollectionContext);
+				}
+				ReadOnlySpan<byte> key4 = new[] { (byte)'R', (byte)'o', (byte)'l', (byte)'e' }; // static readonly
+				encoder.EncodeString(key4, 4, writer, context.CancellationToken);
+				if (obj.Roles == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeArrayStart(obj.Roles.Count, writer, context.CollectionContext); // OMITTABLE
+					var i = 0; // OMITTABLE
+					foreach (var item in obj.Roles)
+					{
+						encoder.EncodeArrayItemStart(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeString(item, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+						encoder.EncodeArrayItemEnd(i, writer, context.CollectionContext); // OMITTABLE
+					}
+					encoder.EncodeArrayEnd(obj.Roles.Count, writer, context.CollectionContext);
+				}
+				encoder.EncodeMapEnd(5, writer, context.CollectionContext); // OMITTABLE
+			}
+		}
+
+		public async ValueTask SerializeAsync(SerializationOperationContext context, SampleObject obj, Stream streamSink)
+		{
+			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
+			{
+				this.Serialize(context, obj, writer);
+			}
+		}
+
+		private static readonly MsgPackStringTrie<uint> DeserializationTrie = InitializeDeserializationTrie();
+		private static MsgPackStringTrie<uint> InitializeDeserializationTrie()
+		{
+			ReadOnlySpan<byte> __name = new byte[] { 0xA4, (byte)'N', (byte)'a', (byte)'m', (byte)'e' };
+			ReadOnlySpan<byte> __age = new byte[] { 0xA3, (byte)'A', (byte)'g', (byte)'e' };
+			ReadOnlySpan<byte> __isActive = new byte[] { 0xAA, (byte)'i', (byte)'s', (byte)'A', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e' };
+			ReadOnlySpan<byte> __roles = new byte[] { 0xA4, (byte)'N', (byte)'a', (byte)'m', (byte)'e', };
+			ReadOnlySpan<byte> __attributes = new byte[] { 0xAC, (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s' };
+			var trie = new MsgPackStringTrie<uint>(5);
+			trie.TryAdd(__name, 0);
+			trie.TryAdd(__age, 1);
+			trie.TryAdd(__isActive, 2);
+			trie.TryAdd(__roles, 3);
+			trie.TryAdd(__attributes, 4);
+			return trie;
+		}
+
+		public SampleObject Deserialize(in DeserializationOperationContext context, in SequenceReader<byte> reader)
+		{
+			// T が参照型でデフォルトコンストラクターがある -> DeserializeTo
+			var obj = new SampleObject();
+			this.DeserializeTo(context, reader, obj);
+			return obj;
+
+			// T にデフォルトコンストラクターがない -> from DeserializeTo と同じ処理をインライン実装
+			// ....
+			// return new SampleObject(name, age, isActive, roles, attributes);
+
+			// T がミュータブルな値型
+			// ...
+			// var obj = default;
+			// obj.Name = name;
+			// obj.Age = age;
+			// obj.IsActive = isActive;
+			// obj.Roles = roles; // Roles は絶対に null のはず。
+			// obj.Attributes = attributes; // Attributes は絶対に null のはず。
+			// return obj;
+		}
+
+		public async ValueTask<SampleObject> DeserializeAsync(DeserializationOperationContext context, Stream streamSource)
+		{
+			// T が参照型でデフォルトコンストラクターがある -> DeserializeToAsync
+			var obj = new SampleObject();
+			await this.DeserializeToAsync(context, streamSource, obj).ConfigureAwait(false);
+			return obj;
+
+			// T にデフォルトコンストラクターがない -> DeserializeToAsync と同じ処理をインライン実装
+			// ....
+			// return new SampleObject(name, age, isActive, roles, attributes);
+
+			// T がミュータブルな値型
+			// ...
+			// var obj = default;
+			// obj.Name = name;
+			// obj.Age = age;
+			// obj.IsActive = isActive;
+			// obj.Roles = roles; // Roles は絶対に null のはず。
+			// obj.Attributes = attributes; // Attributes は絶対に null のはず。
+			// return obj;
+		}
+
+		public void DeserializeTo(in DeserializationOperationContext context, in SequenceReader<byte> reader, in SampleObject obj)
+		{
+			string name = default!;
+			int age = default;
+			bool isActive = default;
+			var roles = obj.Roles;
+			var attributes = obj.Attributes;
+
+			var decoder = context.Decoder;
+			CollectionType arrayOrMap;
+			long itemsCount;
+			CollectionItemIterator propertyIterator;
+
+			if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+				arrayOrMap = decoder.DecodeArrayOrMapHeader(reader, out itemsCount);
+				if (itemsCount < 5)
+				{
+					throw new MessageTypeException(); // Use Throws
+				}
+
+				propertyIterator = default;
+			}
+			else
+			{
+				arrayOrMap = decoder.DecodeArrayOrMap(reader, out propertyIterator);
+				itemsCount = -1;
+			}
+
+			context.IncrementDepth();
+
+			// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
+			if (arrayOrMap.IsArray)
+			{
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(reader, ref propertyIterator);
+				}
+
+				name = decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(reader, ref propertyIterator);
+				}
+
+				age = decoder.DecodeInt32(reader);
+
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(reader, ref propertyIterator);
+				}
+
+				isActive = decoder.DecodeBoolean(reader);
+
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(reader, ref propertyIterator);
+				}
+
+				context.IncrementDepth();
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					var arrayLength = decoder.DecodeArrayHeader(reader);
+					// If settable
+					//if (roles == null)
+					//{
+					//	roles = new List<string>(arrayLength); // or 0
+					//}
+
+					for (var i = 0; i < arrayLength; i++)
+					{
+						roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+					}
+				}
+				else
+				{
+					var iterator = decoder.DecodeArray(reader);
+					while (!iterator.CollectionEnds(reader))
+					{
+						roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+					}
+					iterator.Drain(reader); 
+				}
+				context.DecrementDepth();
+
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(reader, ref propertyIterator);
+				}
+
+				context.IncrementDepth();
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					var mapCount = decoder.DecodeMapHeader(reader);
+					// If settable
+					//if (attributes == null)
+					//{
+					//	attributes = new Dictionary<string, string>(mapCount); // or 0
+					//}
+					for (var i = 0; i < mapCount; i++)
+					{
+						attributes.Add(
+							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+						);
+					}
+				}
+				else
+				{
+					var iterator = decoder.DecodeMap(reader);
+					while (!iterator.CollectionEnds(reader))
+					{
+						attributes.Add(
+							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+						);
+					}
+					iterator.Drain(reader);
+				}
+				context.DecrementDepth();
+			}
+			else
+			{
+				// Map
+
+				// if !decoder.FormatFeatures.CanCountCollectionItems // OPTIMIZABLE
+				// while(!propertyIterator.CollectionEnds(reader))
+				for (var i = 0; i < itemsCount; i++)
+				{
+					decoder.GetRawString(reader, out ReadOnlySpan<byte> key, context.CancellationToken);
+
+					context.ValidatePropertyKeyLength(reader.Consumed, key.Length);
+
+					// Use inlined trie, prefixed by the count as MP uint32.
+					// char is UTF-8, big endian.
+					// 1st node: [length(1-5)][chars(7-3)]
+					switch (DeserializationTrie.GetOrDefault(key))
+					{
+						case 0:
+						{
+							name = decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+							break;
+						}
+						case 1:
+						{
+							age = decoder.DecodeInt32(reader);
+							break;
+						}
+						case 2:
+						{
+							isActive = decoder.DecodeBoolean(reader);
+							break;
+						}
+						case 3:
+						{
+							context.IncrementDepth();
+							if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+							{
+								var arrayLength = decoder.DecodeArrayHeader(reader);
+								// If settable
+								//if (roles == null)
+								//{
+								//	roles = new List<string>(arrayLength); // or 0
+								//}
+								for (var j = 0; j < arrayLength; j++)
+								{
+									roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+								}
+							}
+							else
+							{
+								var iterator = decoder.DecodeArray(reader);
+								while (!iterator.CollectionEnds(reader))
+								{
+									roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+								}
+								iterator.Drain(reader);
+							}
+							context.DecrementDepth();
+							break;
+						}
+						case 4:
+						{
+							context.IncrementDepth();
+							if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+							{
+								var mapCount = decoder.DecodeMapHeader(reader);
+								// If settable
+								//if (attributes == null)
+								//{
+								//	attributes = new Dictionary<string, string>(mapCount); // or 0
+								//}
+								for (var j = 0; j < mapCount; j++)
+								{
+									attributes.Add(
+										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+									);
+								}
+							}
+							else
+							{
+								var iterator = decoder.DecodeMap(reader);
+								while (!iterator.CollectionEnds(reader))
+								{
+									attributes.Add(
+										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+									);
+								}
+								iterator.Drain(reader);
+							}
+							context.DecrementDepth();
+							break;
+						}
+					}
+				}
+			}
+
+			if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+				decoder.Drain(reader, context.CollectionContext, itemsCount - 5, context.CancellationToken);
+			}
+			else
+			{
+				propertyIterator.Drain(reader);
+			}
+
+			context.DecrementDepth();
+
+			obj.Name = name;
+			obj.Age = age;
+			obj.IsActive = isActive;
+			// If settable
+			// obj.Roles = roles;
+			// If settable
+			// obj.Attributes = attributes;
+		}
+
+		private static void CheckNextItemExists(SequenceReader<byte> reader, ref CollectionItemIterator propertyIterator)
+		{
+			if (!propertyIterator.CollectionEnds(reader))
+			{
+				throw new MessageTypeException(); // Use Throws
+			}
+		}
+
+		private static bool TryDecodeArrayOrMapHeader(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
+		{
+			context.IncrementDepth();
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(reader, out itemsCount, out requestHint);
+			if (arrayOrMap.IsNone)
+			{
+				return false;
+			}
+
+			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+				if (itemsCount < 5)
+				{
+					throw new MessageTypeException(); // Use Throws
+				}
+			}
+
+			memory = memory.Slice(unchecked((int)reader.Consumed));
+
+			return true;
+		}
+
+		private static bool TryDecodeArrayHeader(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out int arrayLength, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			arrayLength = context.Decoder.DecodeArrayHeader(reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeMapHeader(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out int mapCount, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			mapCount = context.Decoder.DecodeMapHeader(reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfName(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string name, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			name = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfAge(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out int age, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			age = context.Decoder.DecodeInt32(reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfIsActive(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out bool isActive, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			isActive = context.Decoder.DecodeBoolean(reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeItemOfRoles(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string item, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			item = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeKeyOfAttributes(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string key, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			key = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfAttributes(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string value, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			value = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeArray(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			iterator = context.Decoder.DecodeArray(reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeMap(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			iterator = context.Decoder.DecodeMap(reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryGetRawString(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, [NotNullWhen(true)]out byte[] key, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			ReadOnlySpan<byte> span;
+			if (!context.Decoder.GetRawString(reader, out span, out requestHint, context.CancellationToken))
+			{
+				key = default!;
+				return false;
+			}
+
+			key = context.ArrayPool.Rent(span.Length);
+			span.CopyTo(key);
+			return true;
+		}
+
+		private static bool TryDrain(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, int remaining, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			context.Decoder.Drain(reader, context.CollectionContext, remaining, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private bool TryCheckNextItemExists(ref CollectionItemIterator propertyIterator, ReadOnlyMemory<byte> memory, out int requestHint)
+		{
+			if (propertyIterator.CollectionEnds(memory, out requestHint))
+			{
+				throw new MessageTypeException(); // use throws
+			}
+
+			return requestHint == 0;
+		}
+
+		public async ValueTask DeserializeToAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource, SampleObject obj)
+		{
+			// T が値型
+			// throw new NotSupportedException();
+
+			var buffer = context.ArrayPool.Rent(2 * 1024 * 1024);
+			try
+			{
+				var provider = new StreamReadOnlyMemoryProvider(streamSource, buffer);
+				var memory = await provider.GetNextAsync(default, 0, context.CancellationToken).ConfigureAwait(false);
+				int requestHint;
+
+				string name = default!;
+				int age = default;
+				bool isActive = default;
+				var roles = obj.Roles;
+				var attributes = obj.Attributes;
+
+				var decoder = context.Decoder;
+				context.IncrementDepth();
+
+				long itemsCount;
+				CollectionType arrayOrMap;
+				CollectionItemIterator propertyIterator;
+				while (!TryDecodeArrayOrMapHeader(context, ref memory, out itemsCount, out arrayOrMap, out propertyIterator, out requestHint))
+				{
+					memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+				}
+
+				// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
+				if (arrayOrMap.IsArray)
+				{
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					context.IncrementDepth();
+
+					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						long arrayLength;
+						while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						// If settable
+						//if (roles == null)
+						//{
+						//	roles = new List<string>(arrayLength); // or 0
+						//}
+
+						for (var i = 0; i < arrayLength; i++)
+						{
+							string item;
+							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							roles.Add(item);
+						}
+					}
+					else
+					{
+						CollectionItemIterator iterator;
+						while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						while (!iterator.CollectionEnds(memory, out requestHint))
+						{
+							if (requestHint != 0)
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+
+							string item;
+							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							roles.Add(item);
+						}
+						
+						while(!iterator.Drain(ref memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+					context.DecrementDepth();
+
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					context.IncrementDepth();
+					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						long mapCount;
+						while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						// If settable
+						//if (attributes == null)
+						//{
+						//	attributes = new Dictionary<string, string>(mapCount); // or 0
+						//}
+						for (var i = 0; i < mapCount; i++)
+						{
+							string key;
+							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							string value;
+							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							attributes.Add(key, value);
+						}
+					}
+					else
+					{
+						CollectionItemIterator iterator;
+						while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						while (!iterator.CollectionEnds(memory, out requestHint))
+						{
+							if (requestHint != 0)
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+
+							string key;
+							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							string value;
+							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							attributes.Add(key, value);
+						}
+
+						while (!iterator.Drain(ref memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+					context.DecrementDepth();
+				}
+				else
+				{
+					// Map
+					// #if !context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					// while (!propertyIterator.CollectionEnds(memory, out requestHint))
+					// {
+					//  	if (requestHint != 0)
+					//  	{
+					//  		memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					//			continue;
+					//  	}
+					for (var i = 0; i < itemsCount; i++)
+					{
+						byte[] propertyKey = null!;
+						try
+						{
+							while (!TryGetRawString(context, ref memory, out propertyKey, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+
+							// Use inlined trie, prefixed by the count as MP uint32.
+							// char is UTF-8, big endian.
+							// 1st node: [length(1-5)][chars(7-3)]
+							switch (DeserializationTrie.GetOrDefault(propertyKey))
+							{
+								case 0:
+								{
+									while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
+									{
+										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									break;
+								}
+								case 1:
+								{
+									while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
+									{
+										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									break;
+								}
+								case 2:
+								{
+									while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
+									{
+										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									break;
+								}
+								case 3:
+								{
+									context.IncrementDepth();
+									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+									{
+										long arrayLength;
+										while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										// If settable
+										//if (roles == null)
+										//{
+										//	roles = new List<string>(arrayLength); // or 0
+										//}
+										for (var j = 0; j < arrayLength; j++)
+										{
+											string item;
+											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											roles.Add(item);
+										}
+									}
+									else
+									{
+										CollectionItemIterator iterator;
+										while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										while (!iterator.CollectionEnds(memory, out requestHint))
+										{
+											if (requestHint != 0)
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											string item;
+											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											roles.Add(item);
+										}
+
+										while (!iterator.Drain(ref memory, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+									}
+									context.DecrementDepth();
+									break;
+								}
+								case 4:
+								{
+									context.IncrementDepth();
+									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+									{
+										long mapCount;
+										while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										// If settable
+										//if (attributes == null)
+										//{
+										//	attributes = new Dictionary<string, string>(mapCount); // or 0
+										//}
+										for (var j = 0; j < mapCount; j++)
+										{
+											string key;
+											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+											string value;
+											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											attributes.Add(key, value);
+										}
+									}
+									else
+									{
+										CollectionItemIterator iterator;
+										while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										while (!iterator.CollectionEnds(memory, out requestHint))
+										{
+											if (requestHint != 0)
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											string key;
+											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+											string value;
+											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											attributes.Add(key, value);
+										}
+
+										while (!iterator.Drain(ref memory, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+									}
+									context.DecrementDepth();
+									break;
+								}
+							}
+						}
+						finally
+						{
+							if (propertyKey != null)
+							{
+								context.ArrayPool.Return(propertyKey);
+							}
+						}
+					}
+				}
+
+				if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					itemsCount -= 5;
+					while (!TryDrain(context, ref memory, itemsCount, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+				else
+				{
+					while(!propertyIterator.Drain(ref memory, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+
+				context.DecrementDepth();
+
+				obj.Name = name;
+				obj.Age = age;
+				obj.IsActive = isActive;
+				// If settable
+				// obj.Roles = roles;
+				// If settable
+				// obj.Attributes = attributes;
+			}
+			finally
+			{
+				context.ArrayPool.Return(buffer, clearArray: true);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Extensions/MsgPack.Extensions.csproj b/src/MsgPack.Extensions/MsgPack.Extensions.csproj
new file mode 100644
index 000000000..cb6319069
--- /dev/null
+++ b/src/MsgPack.Extensions/MsgPack.Extensions.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/MsgPack.Json/Json/JsonEncoder.cs b/src/MsgPack.Json/Json/JsonEncoder.cs
new file mode 100644
index 000000000..721247c94
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonEncoder.cs
@@ -0,0 +1,784 @@
+using System;
+using System.Buffers;
+using System.Buffers.Text;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	internal static class JsonTokens
+	{
+		public static readonly ReadOnlyMemory<byte> Null = new[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
+		public static readonly ReadOnlyMemory<byte> True = new[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e' };
+		public static readonly ReadOnlyMemory<byte> False = new[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e' };
+		public static readonly ReadOnlyMemory<byte> ArrayStart = new[] { (byte)'[' };
+		public static readonly ReadOnlyMemory<byte> ArrayEnd = new[] { (byte)']' };
+		public static readonly ReadOnlyMemory<byte> MapStart = new[] { (byte)'{' };
+		public static readonly ReadOnlyMemory<byte> MapEnd = new[] { (byte)'}' };
+		public static readonly ReadOnlyMemory<byte> Whitespace = new[] { (byte)' ' };
+		public static readonly ReadOnlyMemory<byte> Comma = new[] { (byte)',' };
+		public static readonly ReadOnlyMemory<byte> Colon = new[] { (byte)':' };
+		public static readonly ReadOnlyMemory<byte> Quatation = new[] { (byte)'"' };
+	}
+
+	internal static class JsonCharactor
+	{
+		public static readonly ReadOnlyMemory<byte> MustBeEscaped = new int[] { '\\', '"' }.Concat(Enumerable.Range(0, 0x1F)).Select(i => unchecked((byte)i)).ToArray();
+		public static readonly ReadOnlyMemory<byte> ShouldBeEscaped = new[] { (byte)'/', (byte)'\'', (byte)'<', (byte)'>', (byte)'&' };
+		public static readonly ReadOnlyMemory<byte> CarriageReturn = new[] { (byte)'\r' };
+		public static readonly ReadOnlyMemory<byte> LineFeed = new[] { (byte)'\n' };
+	}
+
+	internal static class JsonEscapeSequence
+	{
+		public static readonly ReadOnlyMemory<byte> Unicode = new[] { (byte)'\\', (byte)'u' };
+
+		public static readonly ReadOnlyMemory<byte> ReverseSolidous = new[] { (byte)'\\', (byte)'\\' };
+		public static readonly ReadOnlyMemory<byte> Quatation = new[] { (byte)'\\', (byte)'"' };
+		public static readonly ReadOnlyMemory<byte> Tab = new[] { (byte)'\\', (byte)'t' };
+		public static readonly ReadOnlyMemory<byte> CarriageReturn = new[] { (byte)'\\', (byte)'r' };
+		public static readonly ReadOnlyMemory<byte> LineFeed = new[] { (byte)'\\', (byte)'n' };
+		public static readonly ReadOnlyMemory<byte> BackSpace = new[] { (byte)'\\', (byte)'b' };
+		public static readonly ReadOnlyMemory<byte> FormFeed = new[] { (byte)'\\', (byte)'f' };
+
+		public static readonly StandardFormat UnicodeFormat = new StandardFormat('X', 4);
+	}
+
+	public enum NaNHandling
+	{
+		Default = 0,
+		Null = 1,
+		Error = 2,
+		Custom = 3
+	}
+
+	public enum InfinityHandling
+	{
+		Default = 0,
+		MinMax = 1,
+		Error = 2,
+		Custom = 3
+	}
+
+	[Flags]
+	public enum JsonParseOptions
+	{
+		None = 0,
+		AllowHashSingleLineComment = 0x1,
+		AllowDoubleSolidousSingleLineComment = 0x2,
+		AllowUnicodeWhitespace = 0x10,
+		AllowAllTrivias = 0xFF,
+		AllowNaN = 0x100,
+		AllowInfinity = 0x200,
+		AllowUndefined = 0x1000,
+		AllowIrregalValues = 0xFF00,
+		AllowEqualSignSeparator = 0x10000,
+		AllowSemicolonDelimiter = 0x20000,
+		AllowExtraComma = 0x40000,
+		AllowSingleQuatationString = 0x100000,
+		AllowUnescapedNewLineInString = 0x200000,
+		AllowUnescapedTabInString = 0x400000,
+		AllowWellknownSyntaxErrors = 0xFF0000,
+		AllowAllErrors = unchecked((int)0xFFFFFFFF)
+	}
+
+	public class JsonEncoderOptionsBase
+	{
+#warning TODO: Options
+	}
+
+	public class JsonEncoderBase : Internal.Encoder
+	{
+#warning TODO: Abstract
+#warning TODO: tuning
+		private static readonly Func<float, Memory<byte>, int> s_singleFormatter =
+			(v, m) => Utf8Formatter.TryFormat(v, m.Span, out var used) ? used : -1;
+		private static readonly Func<float, Memory<byte>, int> s_defaultSingleNanFormatter =
+			(_, m) => WriteNull(m.Span);
+		private static readonly Func<float, Memory<byte>, int> s_defaultSingleInfinityFormatter =
+			(v, m) => Utf8Formatter.TryFormat(v < 0 ? Single.MinValue : Single.MaxValue, m.Span, out var used) ? used : -1;
+
+		private static readonly Func<double, Memory<byte>, int> s_doubleFormatter =
+			(v, m) => Utf8Formatter.TryFormat(v, m.Span, out var used) ? used : -1;
+		private static readonly Func<double, Memory<byte>, int> s_defaultDoubleNanFormatter =
+			(_, m) => WriteNull(m.Span);
+		private static readonly Func<double, Memory<byte>, int> s_defaultDoubleInfinityFormatter =
+			(v, m) => Utf8Formatter.TryFormat(v < 0 ? Single.MinValue : Single.MaxValue, m.Span, out var used) ? used : -1;
+
+		private readonly Func<float, Memory<byte>, int> _singleInfinityFormatter;
+		private readonly Func<float, Memory<byte>, int> _singleNanFormatter;
+		private readonly Func<double, Memory<byte>, int> _doubleInfinityFormatter;
+		private readonly Func<double, Memory<byte>, int> _doubleNanFormatter;
+		private readonly bool _doIndent;
+		private readonly byte[] _indentString;
+		private readonly byte[] _newLine;
+		private readonly ReadOnlyMemory<byte> _toBeEscaped;
+
+		private int _indentLevel;
+
+#warning TODO: Options
+		protected JsonEncoderBase()
+		{
+			this._singleInfinityFormatter = s_defaultSingleInfinityFormatter;
+			this._singleNanFormatter = s_defaultSingleNanFormatter;
+			this._doubleInfinityFormatter = s_defaultDoubleInfinityFormatter;
+			this._doubleNanFormatter = s_defaultDoubleNanFormatter;
+			this._doIndent = false;
+			this._indentString = new[] { (byte)' ', (byte)' ' };
+			this._newLine = new[] { (byte)'\n' };
+			this._toBeEscaped = JsonCharactor.MustBeEscaped;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static int WriteNull(Span<byte> span)
+		{
+			if (span.Length < 4)
+			{
+				return -1;
+			}
+
+			JsonTokens.Null.Span.CopyTo(span);
+			return 4;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void Encode(int value, IBufferWriter<byte> buffer)
+		{
+			var span = buffer.GetSpan();
+			while (true)
+			{
+				if (!Utf8Formatter.TryFormat(value, span, out var used))
+				{
+					span = buffer.GetSpan(span.Length * 2);
+				}
+				else
+				{
+					buffer.Advance(used);
+					break;
+				}
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void Encode(long value, IBufferWriter<byte> buffer)
+		{
+			var span = buffer.GetSpan();
+			while (true)
+			{
+				if (!Utf8Formatter.TryFormat(value, span, out var used))
+				{
+					span = buffer.GetSpan(span.Length * 2);
+				}
+				else
+				{
+					buffer.Advance(used);
+					break;
+				}
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void Encode(float value, IBufferWriter<byte> buffer)
+		{
+			var formatter =
+				Single.IsNaN(value) ?
+				this._singleNanFormatter :
+				Single.IsInfinity(value) ?
+				this._singleInfinityFormatter :
+				s_singleFormatter;
+
+			var memory = buffer.GetMemory();
+			while (true)
+			{
+				var used = formatter(value, memory);
+				if (used < 0)
+				{
+					memory = buffer.GetMemory(memory.Length * 2);
+				}
+				else
+				{
+					buffer.Advance(used);
+					break;
+				}
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void Encode(double value, IBufferWriter<byte> buffer)
+		{
+			var formatter =
+				Double.IsNaN(value) ?
+				this._doubleNanFormatter :
+				Double.IsInfinity(value) ?
+				this._doubleInfinityFormatter :
+				s_doubleFormatter;
+
+			var memory = buffer.GetMemory();
+			while (true)
+			{
+				var used = formatter(value, memory);
+				if (used < 0)
+				{
+					memory = buffer.GetMemory(memory.Length * 2);
+				}
+				else
+				{
+					buffer.Advance(used);
+					break;
+				}
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void Encode(bool value, IBufferWriter<byte> buffer)
+		{
+			if (value)
+			{
+				buffer.Write(JsonTokens.True.Span);
+			}
+			else
+			{
+				buffer.Write(JsonTokens.False.Span);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeNull(IBufferWriter<byte> buffer)
+			=> buffer.Write(JsonTokens.Null.Span);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected void WriteIndent(IBufferWriter<byte> buffer)
+		{
+			if (this._doIndent)
+			{
+				buffer.Write(this._newLine);
+				for (var i = 0; i < this._indentLevel; i++)
+				{
+					buffer.Write(this._indentString);
+				}
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeArrayStart(uint length, IBufferWriter<byte> buffer)
+		{
+			buffer.Write(JsonTokens.ArrayStart.Span);
+			this._indentLevel++;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeArrayEnd(uint length, IBufferWriter<byte> buffer)
+		{
+			this._indentLevel--;
+			this.WriteIndent(buffer);
+			buffer.Write(JsonTokens.ArrayEnd.Span);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeArrayItemStart(uint index, IBufferWriter<byte> buffer)
+		{
+			this.WriteIndent(buffer);
+			if (index > 0)
+			{
+				buffer.Write(JsonTokens.Comma.Span);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeArrayItemEnd(uint index, IBufferWriter<byte> buffer) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeMapStart(uint length, IBufferWriter<byte> buffer)
+		{
+			buffer.Write(JsonTokens.MapStart.Span);
+			this._indentLevel++;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeMapEnd(uint length, IBufferWriter<byte> buffer)
+		{
+			this._indentLevel--;
+			this.WriteIndent(buffer);
+			buffer.Write(JsonTokens.MapEnd.Span);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeMapKeyStart(uint index, IBufferWriter<byte> buffer)
+		{
+			this.WriteIndent(buffer);
+			if (index > 0)
+			{
+				buffer.Write(JsonTokens.Comma.Span);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeMapKeyEnd(uint index, IBufferWriter<byte> buffer) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeMapValueStart(uint index, IBufferWriter<byte> buffer)
+		{
+			buffer.Write(JsonTokens.Colon.Span);
+			if (this._doIndent)
+			{
+				buffer.Write(JsonTokens.Whitespace.Span);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeMapValueEnd(uint index, IBufferWriter<byte> buffer) { }
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static ReadOnlyMemory<byte> GetEscapeSequence(byte c, bool newLineAllowed)
+		{
+			switch (c)
+			{
+				case (byte)'\b':
+				{
+					return JsonEscapeSequence.BackSpace;
+				}
+				case (byte)'\r':
+				{
+					if (newLineAllowed)
+					{
+						// Does not escape.
+						return JsonCharactor.CarriageReturn;
+					}
+
+					return JsonEscapeSequence.CarriageReturn;
+				}
+				case (byte)'\f':
+				{
+					return JsonEscapeSequence.FormFeed;
+				}
+				case (byte)'\n':
+				{
+					if (newLineAllowed)
+					{
+						// Does not escape.
+						return JsonCharactor.LineFeed;
+					}
+
+					return JsonEscapeSequence.LineFeed;
+				}
+				case (byte)'"':
+				{
+					return JsonEscapeSequence.Quatation;
+				}
+				case (byte)'\\':
+				{
+					return JsonEscapeSequence.ReverseSolidous;
+				}
+				case (byte)'\t':
+				{
+					return JsonEscapeSequence.Tab;
+				}
+			}
+
+			// Use \uXXXX
+			return ReadOnlyMemory<byte>.Empty;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer)
+		{
+			buffer.Write(JsonTokens.Quatation.Span);
+
+			this.EncodeStringBody(encodedValue, buffer);
+
+			// End quot
+			buffer.Write(JsonTokens.Quatation.Span);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private void EncodeStringBody(ReadOnlySpan<byte> encodedValue, IBufferWriter<byte> buffer)
+		{
+			var source = encodedValue;
+			var sink = buffer.GetSpan(encodedValue.Length);
+			while (!source.IsEmpty)
+			{
+				var moreBytes = this.EscapeStringContent(source, sink, out var sourceUsed, out var sinkUsed);
+				buffer.Advance(sinkUsed);
+				source = source.Slice(sourceUsed);
+				sink = buffer.GetSpan(moreBytes);
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private int EscapeStringContent(ReadOnlyMemory<byte> source, Memory<byte> sink, out int sourceUsed, out int sinkUsed)
+			=> this.EscapeStringContent(source.Span, sink.Span, out sourceUsed, out sinkUsed);
+
+		private int EscapeStringContent(ReadOnlySpan<byte> source, Span<byte> sink, out int sourceUsed, out int sinkUsed)
+		{
+			sourceUsed = 0;
+			sinkUsed = 0;
+
+			while (!sink.IsEmpty)
+			{
+				var toBeEscaped = source.IndexOfAny(this._toBeEscaped.Span);
+				if (toBeEscaped < 0)
+				{
+					// Copy entire source to sink, and then advance buffer.
+					source.CopyTo(sink);
+					sourceUsed += source.Length;
+					sinkUsed += source.Length;
+					continue;
+				}
+
+				if (toBeEscaped > 0)
+				{
+					// Copy source data which have not to be escaped to sink, and then advance buffer.
+					source.Slice(0, toBeEscaped).CopyTo(sink);
+					sink = sink.Slice(toBeEscaped);
+					sourceUsed += toBeEscaped;
+					sinkUsed += toBeEscaped;
+					source = source.Slice(toBeEscaped);
+				}
+
+#warning TODO: OPTIONS
+				var escapeSequence = GetEscapeSequence(source[0], newLineAllowed: false);
+				switch (escapeSequence.Length)
+				{
+					case 1:
+					{
+						// Does not escape because of the option.
+						sink[0] = source[0];
+						sink = sink.Slice(1);
+						sinkUsed++;
+						break;
+					}
+					case 0:
+					{
+						// \uXXXX escape
+						if (sink.Length < 6)
+						{
+							// Return to expecte realloc.
+							return source.Length + 6;
+						}
+
+						JsonEscapeSequence.Unicode.Span.CopyTo(sink);
+						sink = sink.Slice(2); // \u
+						Utf8Formatter.TryFormat(source[0], sink, out _, JsonEscapeSequence.UnicodeFormat);
+						sink = sink.Slice(4); // xxxx
+						sinkUsed += 6;
+						break;
+					}
+					default:
+					{
+						// Use returned escape sequence
+
+						if (sink.Length < escapeSequence.Length)
+						{
+							// Return to expecte realloc.
+							return source.Length + escapeSequence.Length;
+						}
+
+						escapeSequence.Span.CopyTo(sink);
+						sink = sink.Slice(escapeSequence.Length);
+						sinkUsed += escapeSequence.Length;
+						break;
+					}
+				} // switch
+
+				sourceUsed++;
+				source = source.Slice(1);
+			} // while (!source.IsEmpty)
+
+			return 0;
+		}
+
+		public override void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer)
+		{
+			// Start quot
+			buffer.Write(JsonTokens.Quatation.Span);
+
+			var source = new SequenceReader<byte>(encodedValue);
+
+			while (!source.UnreadSpan.IsEmpty)
+			{
+				var length = source.UnreadSpan.Length;
+				this.EncodeStringBody(source.UnreadSpan, buffer);
+				source.Advance(length);
+			}
+
+			// End quot
+			buffer.Write(JsonTokens.Quatation.Span);
+		}
+
+		public override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			if (value.Length < 256)
+			{
+				// Fast-path with stackalloc
+				var charLength = unchecked((int)value.Length);
+				Span<byte> encodingBuffer = stackalloc byte[encoding.GetMaxByteCount(charLength)];
+				var actualLength = encoding.GetBytes(value, encodingBuffer);
+				this.EncodeString(encodingBuffer.Slice(0, actualLength), charLength, buffer);
+			}
+			else
+			{
+				// Slow-path
+
+				// Start quot
+				buffer.Write(JsonTokens.Quatation.Span);
+
+				var encoder = encoding.GetEncoder();
+				var source = value;
+
+				var encodingBuffer = this.ByteArrayPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
+				try
+				{
+					Span<byte> encodingSpan = encodingBuffer;
+					while (!source.IsEmpty)
+					{
+						var length = source.Length;
+						encoder.Convert(source, encodingSpan, flush: source.Length <= encodingSpan.Length, out var charsUsed, out var bytesUsed, out _);
+
+						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), buffer);
+						source = source.Slice(charsUsed);
+					}
+				}
+				finally
+				{
+					this.ByteArrayPool.Return(encodingBuffer, this.ClearsBufferPool);
+				}
+
+				// End quot
+				buffer.Write(JsonTokens.Quatation.Span);
+			}
+		}
+
+		public override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		{
+			if (value.IsSingleSegment)
+			{
+				this.EncodeString(value.FirstSpan, buffer, encoding);
+				return;
+			}
+
+			if (value.Length < 256)
+			{
+				// Fast-path with stackalloc
+				var charLength = unchecked((int)value.Length);
+				Span<byte> encodingBuffer = stackalloc byte[encoding.GetMaxByteCount(charLength)];
+				var actualLength = encoding.GetBytes(value, encodingBuffer);
+				this.EncodeString(encodingBuffer.Slice(0, actualLength), charLength, buffer);
+			}
+			else
+			{
+				// Slow-path
+
+				// Start quot
+				buffer.Write(JsonTokens.Quatation.Span);
+
+				var encoder = encoding.GetEncoder();
+				var source = new SequenceReader<char>(value);
+
+				var encodingBuffer = this.ByteArrayPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
+				try
+				{
+					Span<byte> encodingSpan = encodingBuffer;
+					while (!source.UnreadSpan.IsEmpty)
+					{
+						var length = source.UnreadSpan.Length;
+						encoder.Convert(source.UnreadSpan, encodingSpan, flush: source.Remaining <= encodingSpan.Length, out var charsUsed, out var bytesUsed, out _);
+
+						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), buffer);
+						source.Advance(charsUsed);
+					}
+				}
+				finally
+				{
+					this.ByteArrayPool.Return(encodingBuffer, this.ClearsBufferPool);
+				}
+
+				// End quot
+				buffer.Write(JsonTokens.Quatation.Span);
+			}
+		}
+
+		protected override async ValueTask<long> EncodeLargeStringCoreAsync(TextReader source, Stream sink, Encoding encoding, Func<Stream> bufferStreamProvider, CancellationToken cancellationToken)
+		{
+			// Start quot
+			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
+			long written = JsonTokens.Quatation.Length;
+
+			var maxBytesPerChar = encoding.GetMaxByteCount(1);
+			var encoder = encoding.GetEncoder();
+			var charBufferLength = ByteBufferLength / maxBytesPerChar;
+
+			var encodingBufferArray = this.ByteArrayPool.Rent(ByteBufferLength);
+			try
+			{
+				var sourceBufferArray = this.CharArrayPool.Rent(charBufferLength);
+				try
+				{
+					var escapingBufferArray = this.ByteArrayPool.Rent(ByteBufferLength);
+					try
+					{
+						Memory<char> sourceBuffer = sourceBufferArray;
+						Memory<byte> encodingBuffer = encodingBufferArray;
+						Memory<byte> escapingBuffer = escapingBufferArray;
+
+						bool completed = false;
+
+						do
+						{
+							var readLength = await source.ReadAsync(sourceBuffer, cancellationToken).ConfigureAwait(false);
+							var shouldFlush = readLength <= sourceBuffer.Length && source.Peek() < 0;
+							var chars = sourceBuffer.Slice(0, readLength);
+							while (!chars.IsEmpty)
+							{
+								encoder.Convert(chars, encodingBuffer, shouldFlush, out var charsUsed, out var bytesUsed, out completed);
+								encodingBuffer = encodingBuffer.Slice(0, bytesUsed);
+
+								while (!encodingBuffer.IsEmpty)
+								{
+									var moreEscapingBufferSize = this.EscapeStringContent(encodingBuffer, escapingBuffer, out var encodingBufferUsed, out var escapingBufferUsed);
+
+									await sink.WriteAsync(escapingBuffer.Slice(0, escapingBufferUsed), cancellationToken).ConfigureAwait(false);
+									written += escapingBufferUsed;
+
+									encodingBuffer = encodingBuffer.Slice(encodingBufferUsed);
+									escapingBuffer = escapingBuffer.Compact(escapingBufferArray, escapingBufferUsed);
+								}
+
+								chars = chars.Slice(charsUsed);
+							}
+						} while (!completed);
+					}
+					finally
+					{
+						this.ByteArrayPool.Return(escapingBufferArray, this.ClearsBufferPool);
+					}
+				}
+				finally
+				{
+					this.CharArrayPool.Return(sourceBufferArray, this.ClearsBufferPool);
+				}
+			}
+			finally
+			{
+				this.ByteArrayPool.Return(encodingBufferArray, this.ClearsBufferPool);
+			}
+
+			// End quot
+			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
+			written += JsonTokens.Quatation.Length;
+
+			return written;
+		}
+
+		public override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer)
+		{
+			// Start quot
+			buffer.Write(JsonTokens.Quatation.Span);
+
+			// Enough space -- over 138% 
+			var span = buffer.GetSpan((int)(value.Length * 1.38));
+			Base64.EncodeToUtf8(value, span, out var bytesConsumed, out var bytesWritten, isFinalBlock: true);
+			buffer.Advance(bytesWritten);
+
+			// End quot
+			buffer.Write(JsonTokens.Quatation.Span);
+		}
+
+		public override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer)
+		{
+			// Start quot
+			buffer.Write(JsonTokens.Quatation.Span);
+
+			var array = this.ByteArrayPool.Rent(ByteBufferLength);
+			try
+			{
+				var reader = new SequenceReader<byte>(value);
+				Span<byte> sourceBuffer = array;
+
+				while (true)
+				{
+					if (!reader.TryCopyTo(sourceBuffer))
+					{
+						while (!reader.End)
+						{
+							reader.UnreadSpan.CopyTo(sourceBuffer);
+							sourceBuffer = sourceBuffer.Slice(0, reader.UnreadSpan.Length);
+							reader.Advance(reader.UnreadSpan.Length);
+						}
+					}
+
+					var span = buffer.GetSpan(sourceBuffer.Length * 2);
+					var status = Base64.EncodeToUtf8(sourceBuffer, span, out var bytesConsumed, out var bytesWritten, reader.End);
+					buffer.Advance(bytesWritten);
+					reader.Advance(bytesConsumed);
+					sourceBuffer = array;
+
+					if (status == OperationStatus.Done && reader.End)
+					{
+						break;
+					}
+				}
+
+				// End quot
+				buffer.Write(JsonTokens.Quatation.Span);
+			}
+			finally
+			{
+				this.ByteArrayPool.Return(array, this.ClearsBufferPool);
+			}
+
+			// End quot
+			buffer.Write(JsonTokens.Quatation.Span);
+		}
+
+		protected override async ValueTask<long> EncodeLargeBinaryCoreAsync(Stream source, Stream sink, Func<Stream> bufferStreamProvider, CancellationToken cancellationToken)
+		{
+			static OperationStatus EncodeBase64ToUtf8(ReadOnlyMemory<byte> sourceMemory, Memory<byte> sinkMemory, out int bytesConsumed, out int bytesWritten, bool isFinalBlock)
+				=> Base64.EncodeToUtf8(sourceMemory.Span, sinkMemory.Span, out bytesConsumed, out bytesWritten, isFinalBlock);
+
+			// End quot
+			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
+			long written = JsonTokens.Quatation.Length;
+
+			var sourceBufferArray = this.ByteArrayPool.Rent(ByteBufferLength / 2);
+			try
+			{
+				var sinkBufferArray = this.ByteArrayPool.Rent(ByteBufferLength);
+				try
+				{
+					Memory<byte> sourceBuffer = sourceBufferArray;
+					Memory<byte> sinkBuffer = sinkBufferArray;
+
+					while (true)
+					{
+						await source.ReadAsync(sourceBuffer, cancellationToken).ConfigureAwait(false);
+
+						var status = EncodeBase64ToUtf8(sourceBuffer, sinkBuffer, out var sourceConsumed, out var sinkWritten, source.Position == source.Length);
+
+						if (status == OperationStatus.Done && source.Position == source.Length)
+						{
+							break;
+						}
+					}
+				}
+				finally
+				{
+					this.ByteArrayPool.Return(sinkBufferArray, this.ClearsBufferPool);
+				}
+			}
+			finally
+			{
+				this.ByteArrayPool.Return(sourceBufferArray, this.ClearsBufferPool);
+			}
+
+			// End quot
+			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
+			written += JsonTokens.Quatation.Length;
+			return written;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/MsgPack.Json.csproj b/src/MsgPack.Json/MsgPack.Json.csproj
new file mode 100644
index 000000000..214660b44
--- /dev/null
+++ b/src/MsgPack.Json/MsgPack.Json.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../MsgPack.Abstraction/MsgPack.Abstraction.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="../MsgPack.Core/Internal/MemoryExtensions.cs" Link="Internal/MemoryExtensions.cs" />
+    <Compile Include="../MsgPack.Core/System.Text/EncodingExtensions.cs" Link="System.Text/EncodingExtensions.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="System.Text/" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/MsgPack.Serialization.Extensions/MsgPack.Serialization.Extensions.csproj b/src/MsgPack.Serialization.Extensions/MsgPack.Serialization.Extensions.csproj
new file mode 100644
index 000000000..cb6319069
--- /dev/null
+++ b/src/MsgPack.Serialization.Extensions/MsgPack.Serialization.Extensions.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj b/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
new file mode 100644
index 000000000..cb6319069
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/MsgPack.Serialization.SourceGeneration/MsgPack.Serialization.SourceGeneration.csproj b/src/MsgPack.Serialization.SourceGeneration/MsgPack.Serialization.SourceGeneration.csproj
new file mode 100644
index 000000000..cb6319069
--- /dev/null
+++ b/src/MsgPack.Serialization.SourceGeneration/MsgPack.Serialization.SourceGeneration.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/MsgPack.Serialization/MsgPack.Serialization.csproj b/src/MsgPack.Serialization/MsgPack.Serialization.csproj
new file mode 100644
index 000000000..d7a9b6293
--- /dev/null
+++ b/src/MsgPack.Serialization/MsgPack.Serialization.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MsgPack.Abstraction\MsgPack.Abstraction.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+</Project>

From 6bed26a1816812e91631dc271325bba50fd0636f Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 14 Jun 2020 22:52:45 +0900
Subject: [PATCH 14/82] Code cleanup

---
 src/MsgPack/MessageNotSupportedException.cs | 12 ++++++------
 src/MsgPack/MessagePackCode.cs              |  2 +-
 src/MsgPack/MessageTypeException.cs         | 10 +++++-----
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/MsgPack/MessageNotSupportedException.cs b/src/MsgPack/MessageNotSupportedException.cs
index 7bb9e077b..1ef21ad74 100644
--- a/src/MsgPack/MessageNotSupportedException.cs
+++ b/src/MsgPack/MessageNotSupportedException.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // MessagePack for CLI
 //
@@ -36,13 +36,13 @@ public sealed class MessageNotSupportedException : Exception
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageNotSupportedException"/> class with the default error message.
 		/// </summary>
-		public MessageNotSupportedException() : this( null ) { }
+		public MessageNotSupportedException() : this(null) { }
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageNotSupportedException"/> class with a specified error message.
 		/// </summary>
 		/// <param name="message">The message that describes the error. </param>
-		public MessageNotSupportedException( string message ) : this( message, null ) { }
+		public MessageNotSupportedException(string? message) : this(message, null) { }
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageNotSupportedException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception. 
@@ -51,7 +51,7 @@ public MessageNotSupportedException( string message ) : this( message, null ) {
 		/// <param name="inner">
 		///		The exception that is the cause of the current exception, or a <c>null</c> if no inner exception is specified.
 		/// </param>
-		public MessageNotSupportedException( string message, Exception inner ) : base( message ?? "Specified object is not supported.", inner ) { }
+		public MessageNotSupportedException(string? message, Exception? inner) : base(message ?? "Specified object is not supported.", inner) { }
 
 #if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		/// <summary>
@@ -68,8 +68,8 @@ public MessageNotSupportedException( string message, Exception inner ) : base( m
 		/// <exception cref="SerializationException">
 		///		The class name is <c>null</c> or <see cref="P:HResult"/> is zero (0).
 		///	</exception>
-		private MessageNotSupportedException( SerializationInfo info, StreamingContext context )
-			: base( info, context ) { }
+		private MessageNotSupportedException(SerializationInfo info, StreamingContext context)
+			: base(info, context) { }
 #endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 	}
 }
diff --git a/src/MsgPack/MessagePackCode.cs b/src/MsgPack/MessagePackCode.cs
index 0ca7a0ab9..44a3838c1 100644
--- a/src/MsgPack/MessagePackCode.cs
+++ b/src/MsgPack/MessagePackCode.cs
@@ -27,7 +27,7 @@
 namespace MsgPack
 {
 #if UNITY && DEBUG
-		public
+	public
 #else
 	internal
 #endif
diff --git a/src/MsgPack/MessageTypeException.cs b/src/MsgPack/MessageTypeException.cs
index e93d18933..7f00d2ba5 100644
--- a/src/MsgPack/MessageTypeException.cs
+++ b/src/MsgPack/MessageTypeException.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // MessagePack for CLI
 //
@@ -36,13 +36,13 @@ public class MessageTypeException : Exception
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with the default error message.
 		/// </summary>
-		public MessageTypeException() : this( null ) { }
+		public MessageTypeException() : this(null) { }
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with a specified error message.
 		/// </summary>
 		/// <param name="message">The message that describes the error. </param>
-		public MessageTypeException( string message ) : this( message, null ) { }
+		public MessageTypeException(string? message) : this(message, null) { }
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception. 
@@ -51,7 +51,7 @@ public MessageTypeException( string message ) : this( message, null ) { }
 		/// <param name="inner">
 		///		The exception that is the cause of the current exception, or a <c>null</c> if no inner exception is specified.
 		/// </param>
-		public MessageTypeException( string message, Exception inner ) : base( message ?? "Invalid message type.", inner ) { }
+		public MessageTypeException(string? message, Exception? inner) : base(message ?? "Invalid message type.", inner) { }
 
 #if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		/// <summary>
@@ -68,7 +68,7 @@ public MessageTypeException( string message, Exception inner ) : base( message ?
 		/// <exception cref="SerializationException">
 		///		The class name is <c>null</c> or <see cref="P:HResult"/> is zero (0).
 		///	</exception>
-		protected MessageTypeException( SerializationInfo info, StreamingContext context ) : base( info, context ) { }
+		protected MessageTypeException(SerializationInfo info, StreamingContext context) : base(info, context) { }
 #endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 	}
 }

From 937c33b925db32209f3d306ae3ea4a413256080b Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 14 Jun 2020 22:25:39 +0900
Subject: [PATCH 15/82] Introduce format neutral ExtensionType

This enables msgpack incompatible formats' extension type handling.
---
 ....Primitives.cs => Decoder`1.Primitives.cs} |  2 +-
 ....Primitives.tt => Decoder`1.Primitives.tt} |  2 +-
 ...ecoder.Strings.cs => Decoder`1.Strings.cs} |  2 +-
 ...ecoder.Strings.tt => Decoder`1.Strings.tt} |  2 +-
 .../Internal/{Decoder.cs => Decoder`1.cs}     | 13 +++--
 ....Primitives.cs => Encoder`1.Primitives.cs} |  2 +-
 ....Primitives.tt => Encoder`1.Primitives.tt} |  2 +-
 .../Internal/{Encoder.cs => Encoder`1.cs}     |  7 +--
 src/MsgPack.Abstraction/Internal/Ensure.cs    | 11 +++++
 .../Internal/NullExtensionType.cs             | 11 +++++
 .../MsgPack.Abstraction.csproj                | 24 ++++-----
 ...s => DeserializationOperationContext`1.cs} | 10 ++--
 .../Internal/IObjectSerializer`1.cs           | 20 --------
 .../Internal/IObjectSerializer`2.cs           | 20 ++++++++
 ....cs => SerializationOperationContext`1.cs} |  9 ++--
 .../{Serializer`1.cs => Serializer`2.cs}      | 22 ++++-----
 .../Internal/CurrentMessagePackEncoder.cs     |  8 +--
 .../Internal/MessagePackDecoder.Extension.cs  |  6 ++-
 .../Internal/MessagePackDecoder.cs            |  2 +-
 .../Internal/MessagePackEncoder.cs            |  2 +-
 .../Internal/MessagePackExtensionType.cs      | 43 ++++++++++++++++
 src/MsgPack.Core/_SampleObject.cs             | 49 +++++++++++--------
 22 files changed, 177 insertions(+), 92 deletions(-)
 rename src/MsgPack.Abstraction/Internal/{Decoder.Primitives.cs => Decoder`1.Primitives.cs} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder.Primitives.tt => Decoder`1.Primitives.tt} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder.Strings.cs => Decoder`1.Strings.cs} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder.Strings.tt => Decoder`1.Strings.tt} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder.cs => Decoder`1.cs} (94%)
 rename src/MsgPack.Abstraction/Internal/{Encoder.Primitives.cs => Encoder`1.Primitives.cs} (99%)
 rename src/MsgPack.Abstraction/Internal/{Encoder.Primitives.tt => Encoder`1.Primitives.tt} (98%)
 rename src/MsgPack.Abstraction/Internal/{Encoder.cs => Encoder`1.cs} (94%)
 create mode 100644 src/MsgPack.Abstraction/Internal/NullExtensionType.cs
 rename src/MsgPack.Abstraction/Serialization/Internal/{DeserializationOperationContext.cs => DeserializationOperationContext`1.cs} (80%)
 delete mode 100644 src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
 rename src/MsgPack.Abstraction/Serialization/Internal/{SerializationOperationContext.cs => SerializationOperationContext`1.cs} (77%)
 rename src/MsgPack.Abstraction/Serialization/{Serializer`1.cs => Serializer`2.cs} (84%)
 create mode 100644 src/MsgPack.Core/Internal/MessagePackExtensionType.cs

diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs
rename to src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
index 9d4066b1a..8c4d48b33 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
@@ -12,7 +12,7 @@
 
 namespace MsgPack.Internal
 {
-	partial class Decoder
+	partial class Decoder<TExtensionType>
 	{
 		/// <summary>
 		///		Decodes <see cref="Byte" /> value from specified sequence.
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt
rename to src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
index 4a4be9e47..c814ebe99 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
@@ -14,7 +14,7 @@ using System.Runtime.CompilerServices;
 
 namespace MsgPack.Internal
 {
-	partial class Decoder
+	partial class Decoder<TExtensionType>
 	{
 <#
 foreach (var outputType in new [] {
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Strings.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder.Strings.cs
rename to src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
index 78a9715d2..17c91200f 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder.Strings.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
@@ -16,7 +16,7 @@
 
 namespace MsgPack.Internal
 {
-	partial class Decoder
+	partial class Decoder<TExtensionType>
 	{
 		/// <summary>
 		///		Decodes <see cref="String" /> value from specified sequence.
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.Strings.tt b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder.Strings.tt
rename to src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
index 4b7a3da9e..ad9ec6506 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder.Strings.tt
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
@@ -18,7 +18,7 @@ using System.Threading;
 
 namespace MsgPack.Internal
 {
-	partial class Decoder
+	partial class Decoder<TExtensionType>
 	{
 <#
 foreach (var spec in new [] {
diff --git a/src/MsgPack.Abstraction/Internal/Decoder.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.cs
similarity index 94%
rename from src/MsgPack.Abstraction/Internal/Decoder.cs
rename to src/MsgPack.Abstraction/Internal/Decoder`1.cs
index 1b5c814da..9e9b30293 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.cs
@@ -9,9 +9,16 @@
 
 namespace MsgPack.Internal
 {
-	public abstract partial class Decoder
 #warning TODO: Use 'Try' prefix for published APIs which can return 'requestHint'.
 
+	/// <summary>
+	///		Defines an interface and basic functionarity of stateless <see cref="Decoder"/>.
+	/// </summary>
+	/// <typeparam name="TExtensionType">A type of extension type.</typeparam>
+	/// <remarks>
+	///		The <see cref="Decoder"/> is stateless, so caller (serializer, writer, etc.) can cache the instance for performance.
+	/// </remarks>
+	public abstract partial class Decoder<TExtensionType>
 	{
 		public FormatFeatures FormatFeatures { get; }
 
@@ -164,13 +171,13 @@ public long DecodeMapHeader(in SequenceReader<byte> source)
 		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
 		public abstract long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint);
 
-		public virtual void DecodeExtension(in SequenceReader<byte> source, out byte typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		public virtual void DecodeExtension(in SequenceReader<byte> source, out TExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			Throw.ExtensionsIsNotSupported();
 			// never
 			body = default;
 			requestHint = -1;
-			typeCode = default;
+			typeCode = default!;
 		}
 
 		public CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator)
diff --git a/src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs
rename to src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
index 3b66f1243..32f4ce55d 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
@@ -12,7 +12,7 @@
 
 namespace MsgPack.Internal
 {
-	partial class Encoder
+	partial class Encoder<TExtensionType>
 	{
 		/// <summary>
 		///		Encodes <see cref="Int32" /> value to specified buffer.
diff --git a/src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
similarity index 98%
rename from src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt
rename to src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
index c94109f3e..4d393c801 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
@@ -14,7 +14,7 @@ using System.Runtime.CompilerServices;
 
 namespace MsgPack.Internal
 {
-	partial class Encoder
+	partial class Encoder<TExtensionType>
 	{
 <#
 foreach (var inputType in new [] {
diff --git a/src/MsgPack.Abstraction/Internal/Encoder.cs b/src/MsgPack.Abstraction/Internal/Encoder`1.cs
similarity index 94%
rename from src/MsgPack.Abstraction/Internal/Encoder.cs
rename to src/MsgPack.Abstraction/Internal/Encoder`1.cs
index 6ef3a7360..55c783099 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder.cs
+++ b/src/MsgPack.Abstraction/Internal/Encoder`1.cs
@@ -13,10 +13,11 @@ namespace MsgPack.Internal
 	/// <summary>
 	///		Defines an interface and basic functionarity of stateless <see cref="Encoder"/>.
 	/// </summary>
+	/// <typeparam name="TExtensionType">A type of extension type.</typeparam>
 	/// <remarks>
 	///		The <see cref="Encoder"/> is stateless, so caller (serializer, reader, etc.) can cache the instance for performance.
 	/// </remarks>
-	public abstract partial class Encoder
+	public abstract partial class Encoder<TExtensionType>
 	{
 		public EncoderOptions Options { get; }
 
@@ -81,10 +82,10 @@ public void EncodeString(string? value, IBufferWriter<byte> buffer, Encoding? en
 
 		public abstract void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
 
-		public virtual void EncodeExtension(sbyte typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
+		public virtual void EncodeExtension(TExtensionType typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
 			=> Throw.ExtensionsIsNotSupported();
 
-		public virtual void EncodeExtension(sbyte typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
+		public virtual void EncodeExtension(TExtensionType typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
 			=> Throw.ExtensionsIsNotSupported();
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
diff --git a/src/MsgPack.Abstraction/Internal/Ensure.cs b/src/MsgPack.Abstraction/Internal/Ensure.cs
index 3927e712f..e2a24c72c 100644
--- a/src/MsgPack.Abstraction/Internal/Ensure.cs
+++ b/src/MsgPack.Abstraction/Internal/Ensure.cs
@@ -41,5 +41,16 @@ public static T IsNotLessThan<T>(T value, T minInclusive, [CallerArgumentExpress
 
 			return value;
 		}
+
+		public static T IsNotGreaterThan<T>(T value, T maxInclusive, [CallerArgumentExpression("value")] string paramName = null!)
+			where T : struct, IComparable<T>
+		{
+			if (value.CompareTo(maxInclusive) > 0)
+			{
+				throw new ArgumentOutOfRangeException(paramName, $"Value cannot be greater than {maxInclusive}.");
+			}
+
+			return value;
+		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/NullExtensionType.cs b/src/MsgPack.Abstraction/Internal/NullExtensionType.cs
new file mode 100644
index 000000000..0de495693
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/NullExtensionType.cs
@@ -0,0 +1,11 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Represents <c>null</c> extension type for underlying formats which do not support extension type.
+	/// </summary>
+	public struct NullExtensionType { }
+}
diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
index 1d0ea90cf..efa4c70c2 100644
--- a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -10,17 +10,17 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Update="Internal/Decoder.Strings.tt">
+    <None Update="Internal\Decoder`1.Strings.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Decoder.Strings.cs</LastGenOutput>
+      <LastGenOutput>Decoder`1.Strings.cs</LastGenOutput>
     </None>
-    <None Update="Internal/Encoder.Primitives.tt">
-      <LastGenOutput>Encoder.Primitives.cs</LastGenOutput>
+    <None Update="Internal\Encoder`1.Primitives.tt">
+      <LastGenOutput>Encoder`1.Primitives.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Internal/Decoder.Primitives.tt">
+    <None Update="Internal\Decoder`1.Primitives.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Decoder.Primitives.cs</LastGenOutput>
+      <LastGenOutput>Decoder`1.Primitives.cs</LastGenOutput>
     </None>
   </ItemGroup>
 
@@ -29,20 +29,20 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Update="Internal\Decoder.Primitives.cs">
+    <Compile Update="Internal\Decoder`1.Primitives.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Decoder.Primitives.tt</DependentUpon>
+      <DependentUpon>Decoder`1.Primitives.tt</DependentUpon>
     </Compile>
-    <Compile Update="Internal\Decoder.Strings.cs">
+    <Compile Update="Internal\Decoder`1.Strings.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Decoder.Strings.tt</DependentUpon>
+      <DependentUpon>Decoder`1.Strings.tt</DependentUpon>
     </Compile>
-    <Compile Update="Internal\Encoder.Primitives.cs">
+    <Compile Update="Internal\Encoder`1.Primitives.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Encoder.Primitives.tt</DependentUpon>
+      <DependentUpon>Encoder`1.Primitives.tt</DependentUpon>
     </Compile>
   </ItemGroup>
   
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
similarity index 80%
rename from src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs
rename to src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
index 2c267e72f..bac67deb3 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
@@ -2,23 +2,23 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
-using System;
 using System.Buffers;
+using System.Text;
 using System.Threading;
 using MsgPack.Internal;
 
 namespace MsgPack.Serialization.Internal
 {
-	public struct DeserializationOperationContext
+	public struct DeserializationOperationContext<TExtensionType>
 	{
-		public Decoder Decoder { get; }
+		public Decoder<TExtensionType> Decoder { get; }
 		public DeserializationOptions Options { get; }
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 		public ArrayPool<byte> ArrayPool => this.Options.ArrayPool;
-		public System.Text.Encoding? StringEncoding => this.Options.StringEncoding;
+		public Encoding? StringEncoding => this.Options.StringEncoding;
 
-		public DeserializationOperationContext(Decoder decoder, DeserializationOptions? options, CancellationToken cancellationToken)
+		public DeserializationOperationContext(Decoder<TExtensionType> decoder, DeserializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Decoder = Ensure.NotNull(decoder);
 			this.Options = options ?? DeserializationOptions.Default;
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs
deleted file mode 100644
index 7f267b7db..000000000
--- a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`1.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System.Buffers;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace MsgPack.Serialization.Internal
-{
-	public interface IObjectSerializer<T>
-	{
-		void Serialize(in SerializationOperationContext context, T obj, IBufferWriter<byte> sink);
-		ValueTask SerializeAsync(SerializationOperationContext context, T obj, Stream streamSink);
-		T Deserialize(in DeserializationOperationContext context, in SequenceReader<byte> source);
-		ValueTask<T> DeserializeAsync(DeserializationOperationContext context, Stream streamSource);
-		void DeserializeTo(in DeserializationOperationContext context, in SequenceReader<byte> source, in T obj);
-		ValueTask DeserializeToAsync(DeserializationOperationContext context, Stream streamSource, T obj);
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
new file mode 100644
index 000000000..00976498a
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
@@ -0,0 +1,20 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace MsgPack.Serialization.Internal
+{
+	public interface IObjectSerializer<T, TExtentionType>
+	{
+		void Serialize(in SerializationOperationContext<TExtentionType> context, T obj, IBufferWriter<byte> sink);
+		ValueTask SerializeAsync(SerializationOperationContext<TExtentionType> context, T obj, Stream streamSink);
+		T Deserialize(in DeserializationOperationContext<TExtentionType> context, in SequenceReader<byte> source);
+		ValueTask<T> DeserializeAsync(DeserializationOperationContext<TExtentionType> context, Stream streamSource);
+		void DeserializeTo(in DeserializationOperationContext<TExtentionType> context, in SequenceReader<byte> source, in T obj);
+		ValueTask DeserializeToAsync(DeserializationOperationContext<TExtentionType> context, Stream streamSource, T obj);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
similarity index 77%
rename from src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs
rename to src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
index 689a70b57..ef6167fc4 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
@@ -3,21 +3,22 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+using System.Text;
 using System.Threading;
 using MsgPack.Internal;
 
 namespace MsgPack.Serialization.Internal
 {
-	public struct SerializationOperationContext
+	public struct SerializationOperationContext<TExtensionType>
 	{
-		public Encoder Encoder { get; }
+		public Encoder<TExtensionType> Encoder { get; }
 		public SerializationOptions Options { get; }
 		private int _currentDepth;
 		public int CurrentDepth => this._currentDepth;
 		public CancellationToken CancellationToken { get; }
-		public System.Text.Encoding? StringEncoding => this.Options.StringEncoding;
+		public Encoding? StringEncoding => this.Options.StringEncoding;
 
-		public SerializationOperationContext(Encoder encoder, SerializationOptions? options, CancellationToken cancellationToken)
+		public SerializationOperationContext(Encoder<TExtensionType> encoder, SerializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Encoder = Ensure.NotNull(encoder);
 			this.Options = options ?? SerializationOptions.Default;
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer`1.cs b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
similarity index 84%
rename from src/MsgPack.Abstraction/Serialization/Serializer`1.cs
rename to src/MsgPack.Abstraction/Serialization/Serializer`2.cs
index bb959aee2..0a5628fab 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
@@ -12,18 +12,18 @@
 
 namespace MsgPack.Serialization
 {
-	public abstract class Serializer<T>
+	public abstract class Serializer<T, TExtentionType>
 	{
-		private readonly Func<Encoder> _encoderFactory;
-		private readonly Func<Decoder> _decoderFactory;
-		private readonly IObjectSerializer<T> _underlying;
+		private readonly Func<Encoder<TExtentionType>> _encoderFactory;
+		private readonly Func<Decoder<TExtentionType>> _decoderFactory;
+		private readonly IObjectSerializer<T, TExtentionType> _underlying;
 		private readonly SerializationOptions _serializationOptions;
 		private readonly DeserializationOptions _deserializationOptions;
 
 		protected Serializer(
-			Func<Encoder> encoderFactory,
-			Func<Decoder> decoderFactory,
-			IObjectSerializer<T> underlying,
+			Func<Encoder<TExtentionType>> encoderFactory,
+			Func<Decoder<TExtentionType>> decoderFactory,
+			IObjectSerializer<T, TExtentionType> underlying,
 			SerializationOptions serializationOptions,
 			DeserializationOptions deserializationOptions
 		)
@@ -35,11 +35,11 @@ DeserializationOptions deserializationOptions
 			this._deserializationOptions = Ensure.NotNull(deserializationOptions);
 		}
 
-		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext context)
-			=> context = new SerializationOperationContext(this._encoderFactory(), this._serializationOptions, cancellationToken);
+		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext<TExtentionType> context)
+			=> context = new SerializationOperationContext<TExtentionType>(this._encoderFactory(), this._serializationOptions, cancellationToken);
 
-		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext context)
-			=> context = new DeserializationOperationContext(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext<TExtentionType> context)
+			=> context = new DeserializationOperationContext<TExtentionType>(this._decoderFactory(), this._deserializationOptions, cancellationToken);
 
 		public void Serialize(T obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default)
 		{
diff --git a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
index 46a753c2a..b8183564b 100644
--- a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
@@ -69,20 +69,20 @@ protected sealed override int EncodeBinaryHeader(uint length, Span<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override void EncodeExtension(sbyte typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
+		public sealed override void EncodeExtension(MessagePackExtensionType typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
 		{
 			EncodeExtensionHeader(typeCode, unchecked((uint)serializedValue.Length), buffer);
 			buffer.Write(serializedValue);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override void EncodeExtension(sbyte typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
+		public sealed override void EncodeExtension(MessagePackExtensionType typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
 		{
 			EncodeExtensionHeader(typeCode, unchecked((uint)serializedValue.Length), buffer);
 			this.WriteRaw(serializedValue, buffer);
 		}
 
-		private static void EncodeExtensionHeader(sbyte typeCode, uint serializedValueLength, IBufferWriter<byte> buffer)
+		private static void EncodeExtensionHeader(MessagePackExtensionType typeCode, uint serializedValueLength, IBufferWriter<byte> buffer)
 		{
 			switch (serializedValueLength)
 			{
@@ -154,7 +154,7 @@ private static void EncodeExtensionHeader(sbyte typeCode, uint serializedValueLe
 			// type code
 			{
 				var span = buffer.GetSpan(1);
-				span[0] = unchecked((byte)typeCode);
+				span[0] = unchecked(typeCode.TypeCode);
 				buffer.Advance(1);
 			}
 		}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
index 6523729bd..de25b0528 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
@@ -104,7 +104,7 @@ private uint ReadExtensionHeader(in SequenceReader<byte> source, out int consume
 			return length;
 		}
 
-		public override void DecodeExtension(in SequenceReader<byte> source, out byte typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		public override void DecodeExtension(in SequenceReader<byte> source, out MessagePackExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			var bodyLength = this.ReadExtensionHeader(source, out var consumed, out requestHint);
 			if (requestHint != 0)
@@ -114,14 +114,16 @@ public override void DecodeExtension(in SequenceReader<byte> source, out byte ty
 				return;
 			}
 
-			if (!this.TryPeek(source, out typeCode))
+			if (!this.TryPeek(source, out byte typeCodeByte))
 			{
 				requestHint = 1;
+				typeCode = default;
 				body = default;
 				return;
 			}
 
 			consumed++;
+			typeCode = new MessagePackExtensionType(typeCodeByte);
 
 			if (source.Remaining < consumed + bodyLength)
 			{
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
index 177a22159..d244bce91 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
@@ -9,7 +9,7 @@
 
 namespace MsgPack.Internal
 {
-	public sealed partial class MessagePackDecoder : Decoder
+	public sealed partial class MessagePackDecoder : Decoder<MessagePackExtensionType>
 	{
 		private static readonly FormatFeatures MessagePackFormatFeatures =
 			new FormatFeaturesBuilder
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
index 9e9023ac9..98fc04b86 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
@@ -14,7 +14,7 @@ namespace MsgPack.Internal
 	/// <summary>
 	///		Common encoder implementation between legacy and current MessagePack format enconders.
 	/// </summary>
-	public abstract partial class MessagePackEncoder : Encoder
+	public abstract partial class MessagePackEncoder : Encoder<MessagePackExtensionType>
 	{
 #warning TODO: Can devirt?
 		public static MessagePackEncoder CreateLegacy(MessagePackEncoderOptions options) => new LegacyMessagePackEncoder(options);
diff --git a/src/MsgPack.Core/Internal/MessagePackExtensionType.cs b/src/MsgPack.Core/Internal/MessagePackExtensionType.cs
new file mode 100644
index 000000000..0287bf17b
--- /dev/null
+++ b/src/MsgPack.Core/Internal/MessagePackExtensionType.cs
@@ -0,0 +1,43 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Represents type code of extention types.
+	/// </summary>
+	public readonly struct MessagePackExtensionType : IEquatable<MessagePackExtensionType>
+	{
+		public byte TypeCode { get; }
+		public bool IsSystemType => this.TypeCode < 0;
+
+		internal MessagePackExtensionType(byte typeCode)
+		{
+			this.TypeCode = typeCode;
+		}
+
+		public static MessagePackExtensionType Define(byte typeCode)
+			=> new MessagePackExtensionType(Ensure.IsNotGreaterThan(typeCode, (byte)SByte.MaxValue));
+
+		/// <inheritdoc />
+		public bool Equals(MessagePackExtensionType other)
+			=> this.TypeCode == other.TypeCode;
+
+		/// <inheritdoc />
+		public override bool Equals(object? obj)
+			=> (obj is MessagePackExtensionType other) ? this.Equals(other) : false;
+
+		/// <inheritdoc />
+		public override int GetHashCode()
+			=> this.TypeCode.GetHashCode();
+
+		public static bool operator ==(MessagePackExtensionType left, MessagePackExtensionType right)
+			=> left.Equals(right);
+
+		public static bool operator !=(MessagePackExtensionType left, MessagePackExtensionType right)
+			=> !left.Equals(right);
+	}
+}
diff --git a/src/MsgPack.Core/_SampleObject.cs b/src/MsgPack.Core/_SampleObject.cs
index 9c6e63c35..9641a7143 100644
--- a/src/MsgPack.Core/_SampleObject.cs
+++ b/src/MsgPack.Core/_SampleObject.cs
@@ -15,7 +15,7 @@ namespace MsgPack.Internal
 	internal sealed class SampleObject
 	{
 		public int Age { get; set; }
-		public string Name { get; set; }
+		public string Name { get; set; } = null!;
 		public bool IsActive { get; set; }
 		public IDictionary<string, string> Attributes { get; } = new Dictionary<string, string>();
 		public IList<string> Roles { get; } = new List<string>();
@@ -41,11 +41,11 @@ internal sealed class SampleObject
 	/// <summary>
 	///		Sample hand made serializer.
 	/// </summary>
-	internal sealed class SampleSerializer : IObjectSerializer<SampleObject>
+	internal sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleObject, TExtensionType>
 	{
 		private bool UseArray { get; set; }
 
-		public void Serialize(in SerializationOperationContext context, SampleObject obj, IBufferWriter<byte> writer)
+		public void Serialize(in SerializationOperationContext<TExtensionType> context, SampleObject obj, IBufferWriter<byte> writer)
 		{
 			var encoder = context.Encoder;
 			if (obj == null)
@@ -152,7 +152,7 @@ public void Serialize(in SerializationOperationContext context, SampleObject obj
 			}
 		}
 
-		public async ValueTask SerializeAsync(SerializationOperationContext context, SampleObject obj, Stream streamSink)
+		public async ValueTask SerializeAsync(SerializationOperationContext<TExtensionType> context, SampleObject obj, Stream streamSink)
 		{
 			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
 			{
@@ -177,7 +177,7 @@ private static MsgPackStringTrie<uint> InitializeDeserializationTrie()
 			return trie;
 		}
 
-		public SampleObject Deserialize(in DeserializationOperationContext context, in SequenceReader<byte> reader)
+		public SampleObject Deserialize(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> reader)
 		{
 			// T が参照型でデフォルトコンストラクターがある -> DeserializeTo
 			var obj = new SampleObject();
@@ -199,7 +199,7 @@ public SampleObject Deserialize(in DeserializationOperationContext context, in S
 			// return obj;
 		}
 
-		public async ValueTask<SampleObject> DeserializeAsync(DeserializationOperationContext context, Stream streamSource)
+		public async ValueTask<SampleObject> DeserializeAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource)
 		{
 			// T が参照型でデフォルトコンストラクターがある -> DeserializeToAsync
 			var obj = new SampleObject();
@@ -221,7 +221,7 @@ public async ValueTask<SampleObject> DeserializeAsync(DeserializationOperationCo
 			// return obj;
 		}
 
-		public void DeserializeTo(in DeserializationOperationContext context, in SequenceReader<byte> reader, in SampleObject obj)
+		public void DeserializeTo(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> reader, in SampleObject obj)
 		{
 			string name = default!;
 			int age = default;
@@ -477,15 +477,24 @@ private static bool TryDecodeArrayOrMapHeader(in DeserializationOperationContext
 			arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(reader, out itemsCount, out requestHint);
 			if (arrayOrMap.IsNone)
 			{
+				propertyIterator = default;
 				return false;
 			}
 
 			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
 			{
+				arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(reader, out itemsCount);
 				if (itemsCount < 5)
 				{
 					throw new MessageTypeException(); // Use Throws
 				}
+
+				propertyIterator = default;
+			}
+			else
+			{
+				arrayOrMap = context.Decoder.DecodeArrayOrMap(reader, out propertyIterator);
+				itemsCount = -1;
 			}
 
 			memory = memory.Slice(unchecked((int)reader.Consumed));
@@ -493,7 +502,7 @@ private static bool TryDecodeArrayOrMapHeader(in DeserializationOperationContext
 			return true;
 		}
 
-		private static bool TryDecodeArrayHeader(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out int arrayLength, out int requestHint)
+		private static bool TryDecodeArrayHeader(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long arrayLength, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -505,7 +514,7 @@ private static bool TryDecodeArrayHeader(in DeserializationOperationContext cont
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeMapHeader(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out int mapCount, out int requestHint)
+		private static bool TryDecodeMapHeader(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long mapCount, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -517,7 +526,7 @@ private static bool TryDecodeMapHeader(in DeserializationOperationContext contex
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfName(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string name, out int requestHint)
+		private static bool TryDecodeValueOfName(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string name, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -529,7 +538,7 @@ private static bool TryDecodeValueOfName(in DeserializationOperationContext cont
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfAge(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out int age, out int requestHint)
+		private static bool TryDecodeValueOfAge(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out int age, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -541,7 +550,7 @@ private static bool TryDecodeValueOfAge(in DeserializationOperationContext conte
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfIsActive(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out bool isActive, out int requestHint)
+		private static bool TryDecodeValueOfIsActive(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out bool isActive, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -553,7 +562,7 @@ private static bool TryDecodeValueOfIsActive(in DeserializationOperationContext
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeItemOfRoles(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string item, out int requestHint)
+		private static bool TryDecodeItemOfRoles(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string item, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -565,7 +574,7 @@ private static bool TryDecodeItemOfRoles(in DeserializationOperationContext cont
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeKeyOfAttributes(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string key, out int requestHint)
+		private static bool TryDecodeKeyOfAttributes(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string key, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -577,11 +586,11 @@ private static bool TryDecodeKeyOfAttributes(in DeserializationOperationContext
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfAttributes(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out string value, out int requestHint)
+		private static bool TryDecodeValueOfAttributes(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string value, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
-			value = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+			value = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
 			if (requestHint == 0)
 			{
 				memory = memory.Slice(unchecked((int)reader.Consumed));
@@ -589,7 +598,7 @@ private static bool TryDecodeValueOfAttributes(in DeserializationOperationContex
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeArray(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		private static bool TryDecodeArray(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -601,7 +610,7 @@ private static bool TryDecodeArray(in DeserializationOperationContext context, r
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeMap(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		private static bool TryDecodeMap(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -613,7 +622,7 @@ private static bool TryDecodeMap(in DeserializationOperationContext context, ref
 			return requestHint == 0;
 		}
 
-		private static bool TryGetRawString(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, [NotNullWhen(true)]out byte[] key, out int requestHint)
+		private static bool TryGetRawString(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, [NotNullWhen(true)]out byte[] key, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 
@@ -629,7 +638,7 @@ private static bool TryGetRawString(in DeserializationOperationContext context,
 			return true;
 		}
 
-		private static bool TryDrain(in DeserializationOperationContext context, ref ReadOnlyMemory<byte> memory, int remaining, out int requestHint)
+		private static bool TryDrain(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, long remaining, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
 			context.Decoder.Drain(reader, context.CollectionContext, remaining, out requestHint);

From 5024dcd5370f7d019b1ef52642ecfc31945dede3 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 14 Jun 2020 22:26:21 +0900
Subject: [PATCH 16/82] Refine DecodeItem API

---
 .../Internal/DecodeItemResult`1.cs            | 74 +++++++++++++++++++
 src/MsgPack.Abstraction/Internal/Decoder`1.cs |  2 +-
 .../Internal/MessagePackDecoder.DecodeItem.cs | 68 +++++++++++------
 3 files changed, 119 insertions(+), 25 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs

diff --git a/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs b/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
new file mode 100644
index 000000000..96e2d8db7
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
@@ -0,0 +1,74 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Represetns a result of <see cref="Decoder.DecodeItem"/>.
+	/// </summary>
+	public readonly struct DecodeItemResult<TExtensionType>
+	{
+		public bool HasValue => this.ElementType != ElementType.None;
+		public ElementType ElementType { get; }
+		public ReadOnlySequence<byte> Value { get; }
+		public CollectionItemIterator CollectionIterator { get; }
+		public long CollectionLength { get; }
+		public TExtensionType ExtensionType { get; }
+		public ReadOnlySequence<byte> ExtensionBody => this.Value;
+		public long RequestHint { get; }
+
+		private DecodeItemResult(
+			ElementType elementType,
+			in ReadOnlySequence<byte> value = default,
+			in CollectionItemIterator collectionIterator = default,
+			long collectionLength = default,
+			TExtensionType extensionType = default,
+			long requestHint = default
+		)
+		{
+			this.ElementType = elementType;
+			this.Value = value;
+			this.CollectionIterator = collectionIterator;
+			this.CollectionLength = collectionLength;
+			this.ExtensionType = extensionType;
+			this.RequestHint = requestHint;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> CollectionHeader(ElementType elementType, in CollectionItemIterator iterator, long length = -1)
+			=> new DecodeItemResult<TExtensionType>(elementType, collectionIterator: iterator, collectionLength: length);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> ScalarOrSequence(ElementType elementType, ReadOnlyMemory<byte> value)
+			=> ScalarOrSequence(elementType, new ReadOnlySequence<byte>(value));
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> ScalarOrSequence(ElementType elementType, in ReadOnlySequence<byte> value)
+			=> new DecodeItemResult<TExtensionType>(elementType, value: value);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> Null()
+			=> new DecodeItemResult<TExtensionType>(ElementType.Null);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> True()
+			=> new DecodeItemResult<TExtensionType>(ElementType.True);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> False()
+			=> new DecodeItemResult<TExtensionType>(ElementType.False);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> ExtensionTypeObject(TExtensionType extensionType, in ReadOnlySequence<byte> body)
+			=> new DecodeItemResult<TExtensionType>(ElementType.Extension, extensionType : extensionType, value : body);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult<TExtensionType> InsufficientInput(long requestHint)
+			=> new DecodeItemResult<TExtensionType>(ElementType.None, requestHint: requestHint);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.cs
index 9e9b30293..74d52cfc0 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.cs
@@ -44,7 +44,7 @@ public void Skip(in SequenceReader<byte> source, in CollectionContext collection
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public bool TryPeek(in SequenceReader<byte> source, out byte value) => source.TryRead(out value);
 
-		public abstract ElementType DecodeItem(in SequenceReader<byte> source, out ReadOnlySequence<byte> valueOrLength, out int requestHint, CancellationToken cancellationToken = default);
+		public abstract bool DecodeItem(in SequenceReader<byte> source, out DecodeItemResult<TExtensionType> result, CancellationToken cancellationToken = default);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, CancellationToken cancellationToken = default)
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
index d3e8190ca..b5950552a 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
@@ -12,14 +12,13 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		public sealed override ElementType DecodeItem(in SequenceReader<byte> source, out ReadOnlySequence<byte> valueOrLength, out int requestHint, CancellationToken cancellationToken = default)
+		public sealed override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemResult<MessagePackExtensionType> result, CancellationToken cancellationToken = default)
 		{
-			var elementType = this.ReadHeader(source, out var consumed, out var valueOrLengthScalar, out var requestHint32);
-			if (requestHint32 != 0)
+			var elementType = this.ReadHeader(source, out var consumed, out var valueOrLength, out var requestHint);
+			if (requestHint != 0)
 			{
-				requestHint = requestHint32;
-				valueOrLength = default;
-				return ElementType.Null;
+				result = DecodeItemResult<MessagePackExtensionType>.InsufficientInput(requestHint);
+				return false;
 			}
 
 			requestHint = 0;
@@ -27,10 +26,18 @@ public sealed override ElementType DecodeItem(in SequenceReader<byte> source, ou
 			switch (elementType)
 			{
 				case ElementType.True:
+				{
+					result = DecodeItemResult<MessagePackExtensionType>.True();
+					break;
+				}
 				case ElementType.False:
+				{
+					result = DecodeItemResult<MessagePackExtensionType>.False();
+					break;
+				}
 				case ElementType.Null:
 				{
-					valueOrLength = default;
+					result = DecodeItemResult<MessagePackExtensionType>.Null();
 					break;
 				}
 				case ElementType.Int32:
@@ -38,55 +45,68 @@ public sealed override ElementType DecodeItem(in SequenceReader<byte> source, ou
 				{
 					var buffer = new byte[sizeof(int)];
 					var span = MemoryMarshal.Cast<byte, int>(buffer);
-					span[0] = (int)valueOrLengthScalar;
-					valueOrLength = new ReadOnlySequence<byte>(buffer);
+					span[0] = (int)valueOrLength;
+					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, buffer);
 					break;
 				}
 				case ElementType.Array:
 				case ElementType.Map:
+				{
+					this.DecodeArrayOrMap(source, out var iterator);
+					result = DecodeItemResult<MessagePackExtensionType>.CollectionHeader(elementType, this.CreateIterator((uint)valueOrLength), valueOrLength);
+					break;
+				}
 				case ElementType.Int64:
 				case ElementType.UInt64:
 				case ElementType.Double:
 				{
 					var buffer = new byte[sizeof(long)];
 					var span = MemoryMarshal.Cast<byte, long>(buffer);
-					span[0] = valueOrLengthScalar;
-					valueOrLength = new ReadOnlySequence<byte>(buffer);
+					span[0] = valueOrLength;
+					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, buffer);
 					break;
 				}
 				case ElementType.String:
 				case ElementType.Binary:
 				{
-					if (source.Remaining < valueOrLengthScalar + consumed)
+					if (source.Remaining < valueOrLength + consumed)
 					{
-						requestHint = (int)((valueOrLengthScalar + consumed - source.Remaining) & Int32.MaxValue);
-						valueOrLength = default;
-						return default;
+						result =
+							DecodeItemResult < MessagePackExtensionType >.InsufficientInput(
+								(int)((valueOrLength + consumed - source.Remaining) & Int32.MaxValue)
+							);
+						return false;
 					}
 
-					valueOrLength = source.Sequence.Slice(source.Consumed + consumed, valueOrLengthScalar);
-					consumed += valueOrLengthScalar;
+					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, source.Sequence.Slice(source.Consumed + consumed, valueOrLength));
+					consumed += valueOrLength;
 					break;
 				}
 				default:
 				{
 					Debug.Assert(elementType == ElementType.Extension, $"elementType({elementType}, 0x{elementType:X8}) == ElementType.Extension");
 
-					if(source.Remaining < valueOrLengthScalar + consumed)
+					if(source.Remaining < valueOrLength + consumed)
 					{
-						requestHint = (int)((valueOrLengthScalar + consumed - source.Remaining) & Int32.MaxValue);
-						valueOrLength = default;
-						return default;
+						result =
+							DecodeItemResult<MessagePackExtensionType>.InsufficientInput(
+								(int)((valueOrLength + consumed - source.Remaining) & Int32.MaxValue)
+							);
+						return false;
 					}
 
-					valueOrLength = source.Sequence.Slice(source.Consumed + consumed, valueOrLengthScalar + 1 /* typeCode */);
-					consumed += valueOrLengthScalar;
+					var extensionSlice = source.Sequence.Slice(source.Consumed + consumed - 1);
+					var typeCode = new MessagePackExtensionType(extensionSlice.FirstSpan[0]);
+					var body = extensionSlice.Slice(1, valueOrLength);
+
+					result = DecodeItemResult<MessagePackExtensionType>.ExtensionTypeObject(typeCode, body);
+					consumed += valueOrLength;
 					break;
 				}
 			}
 
 			source.Advance(consumed);
-			return elementType;
+			return true;
 		}
 
 		private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed, out long valueOrLength, out int requestHint)

From 1888701407d85f0fd97b3395027f13ba612e8030 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 14 Jun 2020 22:48:02 +0900
Subject: [PATCH 17/82] Add document

---
 .../Internal/FormatFeatures.cs                | 51 ++++++++++++++++++-
 .../Internal/FormatFeaturesBuilder.cs         |  3 +-
 2 files changed, 52 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
index f20f4a578..57a1c8645 100644
--- a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -6,15 +6,64 @@ namespace MsgPack.Internal
 {
 	public sealed class FormatFeatures
 	{
+#warning TODO: REMOVE
 		public bool IsContextful { get; }
+
+		/// <summary>
+		///		Gets a value which indicates the underlying format supports collection length.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng format supports collection length; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
+		///		<list type="bullet">
+		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64)"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64, out System.Int32)"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, System.Threading.CancellationToken)"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, out System.Int32, System.Threading.CancellationToken)"/></item>
+		///		</list>
+		/// </remarks>
 		public bool CanCountCollectionItems { get; }
+
+		/// <summary>
+		///		Gets a value which indicates the underlying format supports custom string encoding.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng format supports custom string encoding; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, <see cref="System.Text.Encoding"/> typed parameters in <see cref="Encoder{TExtensionType}"/> and <see cref="Decoder{TExtensionType}"/> methods will be ignored.
+		/// </remarks>
 		public bool CanSpecifyStringEncoding { get; }
 
+		/// <summary>
+		///		Gets a value which indicates the underlying format supports extension types.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng format supports extension types; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
+		///		<list type="bullet">
+		///			<item><see cref="Encoder{TExtensionType}.EncodeExtension(TExtensionType, System.ReadOnlySpan{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="Encoder{TExtensionType}.EncodeExtension(TExtensionType, System.Buffers.ReadOnlySequence{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="Decoder{TExtensionType}.DecodeExtension(in System.Buffers.SequenceReader{System.Byte}, out TExtensionType, out System.Buffers.ReadOnlySequence{System.Byte}, out System.Int32, System.Threading.CancellationToken)(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///		</list>
+		///		In additon, <c>TExtentionType</c> type parameter should be <see cref="NullExtensionType"/>.
+		/// </remarks>
+		public bool SupportsExtensionTypes { get; }
+
 		internal FormatFeatures(FormatFeaturesBuilder builder)
 		{
 			this.IsContextful = builder.IsContextful;
 			this.CanCountCollectionItems = builder.CanCountCollectionItems;
 			this.CanSpecifyStringEncoding = builder.CanSpecifyStringEncoding;
+			this.SupportsExtensionTypes = builder.SupportsExtensionTypes;
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
index 0a5d3ab2b..66aa16c24 100644
--- a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -9,6 +9,7 @@ public sealed class FormatFeaturesBuilder
 		public bool IsContextful { get; set; }
 		public bool CanCountCollectionItems { get; set; }
 		public bool CanSpecifyStringEncoding { get; set; }
+		public bool SupportsExtensionTypes { get; set; }
 
 		public FormatFeatures Build() => new FormatFeatures(this);
 	}

From e4dc5f37e8de270b9822d17eeaacf3ada0ded95b Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Thu, 11 Jun 2020 23:01:56 +0900
Subject: [PATCH 18/82] WIP: Implement JsonEncoder/JsonDecoder

---
 .../Json/FlexibleJsonDecoder.ReadTrivia.cs    | 103 +++
 src/MsgPack.Json/Json/FlexibleJsonDecoder.cs  |  33 +
 src/MsgPack.Json/Json/InfinityHandling.cs     |  32 +
 src/MsgPack.Json/Json/JsonCharactor.cs        |  22 +
 .../Json/JsonDecoder.CollectionHeaders.cs     |  22 +
 .../Json/JsonDecoder.DecodeItem.cs            | 128 +++
 .../Json/JsonDecoder.Iteration.cs             | 362 ++++++++
 .../Json/JsonDecoder.Nullables.cs             | 173 ++++
 .../Json/JsonDecoder.Nullables.tt             |  57 ++
 .../Json/JsonDecoder.NumberCore.cs            | 254 ++++++
 src/MsgPack.Json/Json/JsonDecoder.Numbers.cs  | 139 ++++
 src/MsgPack.Json/Json/JsonDecoder.Numbers.tt  |  54 ++
 .../Json/JsonDecoder.SkipDrain.cs             |  46 +
 src/MsgPack.Json/Json/JsonDecoder.Strings.cs  | 465 +++++++++++
 src/MsgPack.Json/Json/JsonDecoder.cs          | 166 ++++
 src/MsgPack.Json/Json/JsonDecoderOptions.cs   |  22 +
 .../Json/JsonDecoderOptionsBuilder.cs         |  20 +
 src/MsgPack.Json/Json/JsonEncoder.cs          | 787 ++++++++----------
 src/MsgPack.Json/Json/JsonEncoderOptions.cs   | 116 +++
 .../Json/JsonEncoderOptionsBuilder.cs         | 157 ++++
 src/MsgPack.Json/Json/JsonEscapeSequence.cs   |  26 +
 src/MsgPack.Json/Json/JsonFormatter.cs        |  36 +
 src/MsgPack.Json/Json/JsonNumberTokens.cs     |  95 +++
 .../Json/JsonOptionsValidation.cs             |  61 ++
 src/MsgPack.Json/Json/JsonParseOptions.cs     |  95 +++
 src/MsgPack.Json/Json/JsonStringTokens.cs     |  43 +
 src/MsgPack.Json/Json/JsonThrow.cs            | 117 +++
 src/MsgPack.Json/Json/JsonTokens.cs           |  29 +
 src/MsgPack.Json/Json/JsonTriviaTokens.cs     |  48 ++
 src/MsgPack.Json/Json/NaNHandling.cs          |  32 +
 src/MsgPack.Json/Json/SimpleJsonDecoder.cs    |  27 +
 .../Json/StringBuilderBufferWriter.cs         | 141 ++++
 src/MsgPack.Json/Json/Unicode.cs              |  18 +
 src/MsgPack.Json/MsgPack.Json.csproj          |  28 +
 34 files changed, 3526 insertions(+), 428 deletions(-)
 create mode 100644 src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs
 create mode 100644 src/MsgPack.Json/Json/FlexibleJsonDecoder.cs
 create mode 100644 src/MsgPack.Json/Json/InfinityHandling.cs
 create mode 100644 src/MsgPack.Json/Json/JsonCharactor.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.Iteration.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.Nullables.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.Nullables.tt
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.Numbers.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.Numbers.tt
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.Strings.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoder.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoderOptions.cs
 create mode 100644 src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs
 create mode 100644 src/MsgPack.Json/Json/JsonEncoderOptions.cs
 create mode 100644 src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
 create mode 100644 src/MsgPack.Json/Json/JsonEscapeSequence.cs
 create mode 100644 src/MsgPack.Json/Json/JsonFormatter.cs
 create mode 100644 src/MsgPack.Json/Json/JsonNumberTokens.cs
 create mode 100644 src/MsgPack.Json/Json/JsonOptionsValidation.cs
 create mode 100644 src/MsgPack.Json/Json/JsonParseOptions.cs
 create mode 100644 src/MsgPack.Json/Json/JsonStringTokens.cs
 create mode 100644 src/MsgPack.Json/Json/JsonThrow.cs
 create mode 100644 src/MsgPack.Json/Json/JsonTokens.cs
 create mode 100644 src/MsgPack.Json/Json/JsonTriviaTokens.cs
 create mode 100644 src/MsgPack.Json/Json/NaNHandling.cs
 create mode 100644 src/MsgPack.Json/Json/SimpleJsonDecoder.cs
 create mode 100644 src/MsgPack.Json/Json/StringBuilderBufferWriter.cs
 create mode 100644 src/MsgPack.Json/Json/Unicode.cs

diff --git a/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs b/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs
new file mode 100644
index 000000000..8d09c4f33
--- /dev/null
+++ b/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs
@@ -0,0 +1,103 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Json
+{
+	internal partial class FlexibleJsonDecoder
+	{
+		protected override void ReadTrivia(in SequenceReader<byte> source, out ReadOnlySequence<byte> trivia)
+		{
+			var offset = source.Consumed;
+			var singleByteWhitespaces = (this.Options.ParseOptions & JsonParseOptions.AllowUnicodeWhitespace) == 0 ? JsonTriviaTokens.StandardWhitespaces : JsonTriviaTokens.SingleByteUnicodeWhitespaces;
+
+			var consumed = 0L;
+			while (!source.End)
+			{
+				consumed += source.AdvancePastAny(singleByteWhitespaces);
+
+				if (this.TryReadMultiByteUnicodeWhitespaces(source, ref consumed))
+				{
+					continue;
+				}
+
+				// Single line comment
+				if (this.TryReadSingleLineComment(source, ref consumed))
+				{
+					continue;
+				}
+
+				// Multi line comment
+				if (this.TryReadMultiLineComment(source, ref consumed))
+				{
+					continue;
+				}
+			}
+
+			trivia = source.Sequence.Slice(offset, consumed);
+		}
+
+		private bool TryReadMultiByteUnicodeWhitespaces(in SequenceReader<byte> source, ref long consumed)
+		{
+			if ((this.Options.ParseOptions & JsonParseOptions.AllowUnicodeWhitespace) == 0)
+			{
+				return false;
+			}
+
+			foreach (var whitespace in JsonTriviaTokens.MultiByteUnicodeWhitespaces)
+			{
+				var length = source.AdvancePastAny(whitespace);
+				if (length > 0)
+				{
+					consumed += length;
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		private bool TryReadSingleLineComment(in SequenceReader<byte> source, ref long consumed)
+		{
+			if (((this.Options.ParseOptions & JsonParseOptions.AllowHashSingleLineComment) != 0 && source.IsNext((byte)'#', advancePast: true))
+				|| ((this.Options.ParseOptions & JsonParseOptions.AllowDoubleSolidousSingleLineComment) != 0 && source.IsNext(JsonTriviaTokens.SingleLineCommentStart2, advancePast: true)))
+			{
+				if (!source.TryReadToAny(out ReadOnlySequence<byte> line, JsonTriviaTokens.NewLine, advancePastDelimiter: true))
+				{
+					// to EoF
+					consumed += source.Remaining;
+					source.Advance(source.Remaining);
+					return true;
+				}
+
+				consumed += line.Length;
+				consumed += source.AdvancePastAny(JsonTriviaTokens.NewLine);
+				return true;
+			}
+
+			return false;
+		}
+
+		private bool TryReadMultiLineComment(in SequenceReader<byte> source, ref long consumed)
+		{
+			var offset = source.Consumed;
+
+			if ((this.Options.ParseOptions & JsonParseOptions.AllowMultilineComment) == 0 || !source.IsNext(JsonTriviaTokens.MultiLineCommentStart, advancePast: true))
+			{
+				return false;
+			}
+
+			if (!source.TryReadToAny(out ReadOnlySequence<byte> comment, JsonTriviaTokens.MultiLineCommentEnd, advancePastDelimiter: true))
+			{
+				// */ is not found.
+				source.Rewind(2);
+				return false;
+			}
+
+			consumed += comment.Length;
+			return true;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs b/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs
new file mode 100644
index 000000000..23bc34bcc
--- /dev/null
+++ b/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs
@@ -0,0 +1,33 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Simple <see cref="JsonDecoder"/> implementation which can handle various resource consuming relaxations.
+	/// </summary>
+	internal sealed partial class FlexibleJsonDecoder : JsonDecoder
+	{
+		public FlexibleJsonDecoder(JsonDecoderOptions options)
+			: base(options) { }
+
+		protected override bool TryReadNull(in SequenceReader<byte> source)
+		{
+			if (source.IsNext(JsonTokens.Null, advancePast: true))
+			{
+				return true;
+			}
+
+			if ((this.Options.ParseOptions & JsonParseOptions.AllowUndefined) != 0
+				&& source.IsNext(JsonTokens.Undefined, advancePast: true))
+			{
+				return true;
+			}
+
+			return false;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/InfinityHandling.cs b/src/MsgPack.Json/Json/InfinityHandling.cs
new file mode 100644
index 000000000..abe9026f4
--- /dev/null
+++ b/src/MsgPack.Json/Json/InfinityHandling.cs
@@ -0,0 +1,32 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines positive and/or negative infinity handling in JSON serialization to be compliant with RFC 8259.
+	/// </summary>
+	public enum InfinityHandling
+	{
+		/// <summary>
+		///		Use system default setting. See <see cref="JsonEncoderOptionsBuilder"/> for current default.
+		/// </summary>
+		Default = 0,
+
+		/// <summary>
+		///		Use <c>MinValue</c> for negative infinity and <c>MaxValue</c> for positive infinity.
+		/// </summary>
+		MinMax = 1,
+
+		/// <summary>
+		///		Throws exception conservatively.
+		/// </summary>
+		Error = 2,
+
+		/// <summary>
+		///		Use own custom formatting logic.
+		/// </summary>
+		Custom = 3
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonCharactor.cs b/src/MsgPack.Json/Json/JsonCharactor.cs
new file mode 100644
index 000000000..3c06d41f1
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonCharactor.cs
@@ -0,0 +1,22 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Linq;
+using System.Text;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines JSON constant chars in UTF-8 or related structs.
+	/// </summary>
+	internal static class JsonCharactor
+	{
+		public static readonly byte[] MustBeEscaped1Byte = new[] { (byte)'\\', (byte)'"' };
+		public static readonly ReadOnlyMemory<Rune> ShouldBeEscaped = new[] { (byte)'/', (byte)'\'', (byte)'<', (byte)'>', (byte)'&' }.Select(b => new Rune(b)).ToArray(); // For HTML embedding
+		public static ReadOnlySpan<byte> CarriageReturn => new[] { (byte)'\r' };
+		public static ReadOnlySpan<byte> LineFeed => new[] { (byte)'\n' };
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs b/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
new file mode 100644
index 000000000..cd72d8a69
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
@@ -0,0 +1,22 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	public partial class JsonDecoder
+	{
+		public override CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount, out int requestHint)
+			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out itemsCount, out requestHint);
+
+		public override long DecodeArrayHeader(in SequenceReader<byte> source, out int requestHint)
+			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out requestHint);
+
+		public override long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint)
+			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out requestHint);
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs b/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
new file mode 100644
index 000000000..aca36b59e
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
@@ -0,0 +1,128 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using MsgPack.Internal;
+
+using DecodeItemResult = MsgPack.Internal.DecodeItemResult<MsgPack.Internal.NullExtensionType>;
+
+namespace MsgPack.Json
+{
+	public partial class JsonDecoder
+	{
+		public override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default)
+		{
+			this.ReadTrivia(source, out var trivia);
+			if (!trivia.IsEmpty)
+			{
+				result = DecodeItemResult.ScalarOrSequence(ElementType.OtherTrivia, trivia);
+				return true;
+			}
+
+			if (!this.TryPeek(source, out var token))
+			{
+				result = DecodeItemResult.InsufficientInput(1);
+				return false;
+			}
+
+			switch (token)
+			{
+				case (byte)'t':
+				{
+					if (source.IsNext(JsonTokens.True, advancePast: true))
+					{
+						result = DecodeItemResult.True();
+						return true;
+					}
+
+					break;
+				}
+				case (byte)'f':
+				{
+					if (source.IsNext(JsonTokens.False, advancePast: true))
+					{
+						result = DecodeItemResult.False();
+						return true;
+					}
+
+					break;
+				}
+				case (byte)'n':
+				{
+					if (source.IsNext(JsonTokens.Null, advancePast: true))
+					{
+						result = DecodeItemResult.Null();
+						return true;
+					}
+
+					break;
+				}
+				case (byte)'0':
+				case (byte)'1':
+				case (byte)'2':
+				case (byte)'3':
+				case (byte)'4':
+				case (byte)'5':
+				case (byte)'6':
+				case (byte)'7':
+				case (byte)'8':
+				case (byte)'9':
+				case (byte)'-':
+				case (byte)'+':
+				{
+					var number = this.DecodeNumber(source, out var requestHint);
+					if(requestHint != 0)
+					{
+						result = DecodeItemResult.InsufficientInput(requestHint);
+						return false;
+					}
+
+					var value = new byte[sizeof(double)];
+					Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(value.AsSpan()), number);
+					result = DecodeItemResult.ScalarOrSequence(ElementType.Double, value);
+					return true;
+				}
+				case (byte)'[':
+				{
+					result = DecodeItemResult.CollectionHeader(ElementType.Array, this.CreateArrayIterator());
+					return true;
+				}
+				case (byte)'{':
+				{
+					result = DecodeItemResult.CollectionHeader(ElementType.OtherTrivia, this.CreateObjectPropertyIterator());
+					return true;
+				}
+				case (byte)'\'':
+				{
+					if ((this.Options.ParseOptions & JsonParseOptions.AllowSingleQuotationString) != 0)
+					{
+						goto case (byte)'"';
+					}
+
+					break;
+				}
+				case (byte)'"':
+				{
+					if (this.GetRawStringCore(source, out var rawString, out var requestHint))
+					{
+						result = DecodeItemResult.InsufficientInput(requestHint);
+						return false;
+					}
+
+					result = DecodeItemResult.ScalarOrSequence(ElementType.String, rawString);
+					return true;
+				}
+			}
+
+			JsonThrow.UnexpectedToken(source.Consumed, token);
+			// never
+			result = default;
+			return default;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs b/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs
new file mode 100644
index 000000000..bd8458d2b
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs
@@ -0,0 +1,362 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Diagnostics;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	public partial class JsonDecoder
+	{
+		private sealed class ArrayIterator
+		{
+			private const byte ArrayStartToken = (byte)'[';
+			private const byte ArrayEndToken = (byte)']';
+			private const byte ItemDelimiterToken = (byte)',';
+
+			private readonly JsonDecoder _decoder;
+			private State _state;
+
+			public ArrayIterator(JsonDecoder decoder)
+			{
+				this._decoder = decoder;
+				this._state = State.Head;
+			}
+
+			public bool DetectArrayEnds(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
+			{
+				if (this._state == State.Tail)
+				{
+					requestHint = 0;
+					return true; // End
+				}
+
+				this._decoder.ReadTrivia(source, out _);
+
+				switch (this._state)
+				{
+					case State.Head:
+					{
+						if (!source.TryPeek(out var shouldBeArrayStart))
+						{
+							requestHint = 2;
+							return false;
+						}
+
+						if (shouldBeArrayStart != ArrayStartToken)
+						{
+							// Invalid
+							JsonThrow.UnexpectedToken(source.Consumed, shouldBeArrayStart);
+						}
+
+						source.Advance(1);
+						break;
+					} // case State.Head
+					default:
+					{
+						Debug.Assert(this._state == State.Item, $"this._state {(this._state)} == State.Item");
+
+						if (!source.TryPeek(out var mayBeDelimiterOrArrayEnd))
+						{
+							requestHint = 1;
+							return false;
+						}
+
+						switch (mayBeDelimiterOrArrayEnd)
+						{
+							case ArrayEndToken:
+							{
+								requestHint = 0;
+								source.Advance(1);
+								this._state = State.Tail;
+								return true;
+							} // case ArrayEndToken:
+							case ItemDelimiterToken:
+							{
+								source.Advance(1);
+								// goto maybe-item
+								break;
+							} // ItemDelimiterToken
+							default:
+							{
+								JsonThrow.UnexpectedToken(source.Consumed, mayBeDelimiterOrArrayEnd);
+								// never
+								break;
+							}
+						} // switch (mayBeDelimiterOrArrayEnd)
+
+						break;
+					} // default:
+				} // swtich (this._state)
+
+				// Handle 'maybe item' state
+				this._decoder.ReadTrivia(source, out _);
+				if (!source.TryPeek(out var mayBeArrayEnd))
+				{
+					requestHint = 1;
+					return false;
+				}
+
+				requestHint = 0;
+
+				if (mayBeArrayEnd == ArrayEndToken)
+				{
+					source.Advance(1);
+					this._state = State.Tail;
+					return true;
+				}
+				else
+				{
+					this._state = State.Item;
+					return false;
+				}
+			}
+
+			private enum State
+			{
+				Head = 0,
+				Item,
+				Tail
+			}
+		}
+
+		private sealed class ObjectPropertyIterator
+		{
+			private const byte ObjectStartToken = (byte)'{';
+			private const byte ObjectEndToken = (byte)'}';
+			private const byte KeyValueSepratorToken = (byte)':';
+			private const byte AltKeyValueSepratorToken = (byte)'=';
+			private const byte ItemDelimiterToken = (byte)',';
+
+			private readonly JsonDecoder _decoder;
+			private readonly bool _isEqualSignAllowed;
+			private State _state;
+
+			public ObjectPropertyIterator(JsonDecoder decoder)
+			{
+				this._decoder = decoder;
+				this._state = State.Head;
+				this._isEqualSignAllowed = (decoder.Options.ParseOptions & JsonParseOptions.AllowEqualSignSeparator) != 0;
+			}
+
+			public bool DetectObjectEnds(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
+			{
+				if (this._state == State.Tail)
+				{
+					requestHint = 0;
+					return true; // End
+				}
+
+				this._decoder.ReadTrivia(source, out _);
+
+				switch (this._state)
+				{
+					case State.Head:
+					{
+						if (!source.TryPeek(out var shouldBeObjectStart))
+						{
+							requestHint = 2;
+							return false;
+						}
+
+						if (shouldBeObjectStart != ObjectStartToken)
+						{
+							// Invalid
+							JsonThrow.UnexpectedToken(source.Consumed, shouldBeObjectStart);
+						}
+
+						source.Advance(1);
+						break;
+					} // case State.Head
+					case State.Key:
+					{
+						if (!source.TryPeek(out var mayBeSeparator))
+						{
+							requestHint = 3;
+							return false;
+						}
+
+						switch (mayBeSeparator)
+						{
+							case AltKeyValueSepratorToken:
+							{
+								if (this._isEqualSignAllowed)
+								{
+									goto case KeyValueSepratorToken;
+								}
+								else
+								{
+									goto default;
+								}
+							} // case AltKeyValueSepratorToken
+							case KeyValueSepratorToken:
+							{
+								source.Advance(1);
+								this._state = State.Value;
+								requestHint = 0;
+								return false;
+							} // case KeyValueSepratorToken
+							default:
+							{
+								JsonThrow.UnexpectedToken(source.Consumed, mayBeSeparator);
+								// never
+								requestHint = default;
+								return false;
+							}
+						} // switch (mayBeSeparator)
+
+					} // case State.Key
+					default:
+					{
+						Debug.Assert(this._state == State.Value, $"this._state {(this._state)} == State.Value");
+
+						if (!source.TryPeek(out var mayBeDelimiterOrObjectEnd))
+						{
+							requestHint = 1;
+							return false;
+						}
+
+						switch (mayBeDelimiterOrObjectEnd)
+						{
+							case ObjectEndToken:
+							{
+								source.Advance(1);
+								this._state = State.Tail;
+								requestHint = 0;
+								return true;
+							} // case ObjectEndToken
+							case ItemDelimiterToken:
+							{
+								source.Advance(1);
+								// goto maybe-key
+								break;
+							} // case ItemDelimiterToken
+							default:
+							{
+								JsonThrow.UnexpectedToken(source.Consumed, mayBeDelimiterOrObjectEnd);
+								// never
+								break;
+							}
+						} // switch (mayBeDelimiterOrArrayEnd)
+
+						break;
+					} // default:
+				} // swtich (this._state)
+
+				// Handle 'maybe key' state
+				this._decoder.ReadTrivia(source, out _);
+				if (!source.TryPeek(out var mayBeArrayEnd))
+				{
+					requestHint = 1;
+					return false;
+				}
+
+				requestHint = 0;
+
+				if (mayBeArrayEnd == ObjectEndToken)
+				{
+					source.Advance(1);
+					this._state = State.Tail;
+					return true;
+				}
+				else
+				{
+					this._state = State.Key;
+					return false;
+				}
+			}
+
+			private enum State
+			{
+				Head = 0,
+				Key,
+				Value,
+				Tail
+			}
+		}
+
+		public override CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+
+			if (!this.TryPeek(source, out var token))
+			{
+				requestHint = 1;
+				iterator = default;
+				return CollectionType.None;
+			}
+
+			requestHint = 0;
+			switch (token)
+			{
+				case (byte)'[':
+				{
+					iterator = this.CreateArrayIterator();
+					return CollectionType.Array;
+				}
+				case (byte)'{':
+				{
+					iterator = this.CreateObjectPropertyIterator();
+					return CollectionType.Map;
+				}
+				default:
+				{
+					var offset = source.Consumed;
+					var kind = TryGetUtf8Unit(source, out var sequence);
+					if (kind == Utf8UnitStatus.Valid)
+					{
+						JsonThrow.IsNotArrayNorObject(sequence, offset);
+					}
+					else
+					{
+						JsonThrow.MalformedUtf8(sequence, offset);
+					}
+
+					// never
+					iterator = default;
+					return default;
+				}
+			}
+		}
+
+		private CollectionItemIterator CreateArrayIterator()
+			=> new CollectionItemIterator(new ArrayIterator(this).DetectArrayEnds, -1);
+
+		private CollectionItemIterator CreateObjectPropertyIterator()
+			=> new CollectionItemIterator(new ObjectPropertyIterator(this).DetectObjectEnds, -1);
+
+		public override CollectionItemIterator DecodeArray(in SequenceReader<byte> source, out int requestHint)
+		{
+			var type = this.DecodeArrayOrMap(source, out var iterator, out requestHint);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			if (!type.IsArray)
+			{
+				JsonThrow.IsNotArray(source.Consumed);
+			}
+
+			return iterator;
+		}
+
+		public override CollectionItemIterator DecodeMap(in SequenceReader<byte> source, out int requestHint)
+		{
+			var type = this.DecodeArrayOrMap(source, out var iterator, out requestHint);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			if (!type.IsMap)
+			{
+				JsonThrow.IsNotObject(source.Consumed);
+			}
+
+			return iterator;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs b/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs
new file mode 100644
index 000000000..bfe6936b5
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs
@@ -0,0 +1,173 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	partial class JsonDecoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Byte? DecodeNullableByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeByteCore(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override SByte? DecodeNullableSByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeSByteCore(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int16? DecodeNullableInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeInt16Core(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt16? DecodeNullableUInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeUInt16Core(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int32? DecodeNullableInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeInt32Core(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt32? DecodeNullableUInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeUInt32Core(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int64? DecodeNullableInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeInt64Core(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt64? DecodeNullableUInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeUInt64Core(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Single? DecodeNullableSingle(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeSingleCore(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Double? DecodeNullableDouble(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeDoubleCore(source, out requestHint);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Boolean? DecodeNullableBoolean(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeBooleanCore(source, out requestHint);
+		}
+
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt b/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt
new file mode 100644
index 000000000..c630c16c1
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt
@@ -0,0 +1,57 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	partial class JsonDecoder
+	{
+<#
+foreach (var type in
+	new []
+	{
+		"Byte",
+		"SByte",
+		"Int16",
+		"UInt16",
+		"Int32",
+		"UInt32",
+		"Int64",
+		"UInt64",
+		"Single",
+		"Double",
+		"Boolean"
+	}
+)
+{
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override <#= type #>? DecodeNullable<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.Decode<#= type #>Core(source, out requestHint);
+		}
+
+<#
+} // foreach (var type)
+#>
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs b/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs
new file mode 100644
index 000000000..02c905620
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs
@@ -0,0 +1,254 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Text;
+using System.Diagnostics;
+
+namespace MsgPack.Json
+{
+	public partial class JsonDecoder
+	{
+		public override bool DecodeBoolean(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeBooleanCore(source, out requestHint);
+		}
+
+		private bool DecodeBooleanCore(in SequenceReader<byte> source, out int requestHint)
+		{
+			requestHint = 0;
+			if (source.IsNext(JsonTokens.True, advancePast: true))
+			{
+				return true;
+			}
+			else if (source.IsNext(JsonTokens.False, advancePast: true))
+			{
+				return false;
+			}
+			else
+			{
+				requestHint = GetRequestHintForBoolean(source);
+				return default;
+			}
+		}
+
+		private static int GetRequestHintForBoolean(in SequenceReader<byte> source)
+		{
+			if (!source.TryPeek(out var b))
+			{
+				return 4;
+			}
+
+			switch (b)
+			{
+				case (byte)'t':
+				{
+					return GetRequestHintForBoolean(source, offset: 1, JsonTokens.True);
+				}
+				case (byte)'f':
+				{
+					return GetRequestHintForBoolean(source, offset: 1, JsonTokens.False);
+				}
+			}
+
+			ThrowNonBooleanUtfSequence(source, source.Consumed);
+			// never
+			return default;
+		}
+
+		private static int GetRequestHintForBoolean(in SequenceReader<byte> source, int offset, ReadOnlySpan<byte> expected)
+		{
+			var subReeader = new SequenceReader<byte>(source.Sequence.Slice(source.Consumed + 1));
+
+			for (int i = 0; i < expected.Length; i++)
+			{
+				if (!subReeader.TryRead(out var b))
+				{
+					return expected.Length - i;
+				}
+
+				if (b != expected[i])
+				{
+					ThrowNonBooleanUtfSequence(subReeader, subReeader.Consumed + source.Consumed);
+				}
+			}
+
+			Debug.Fail("should be true/false...");
+			return default;
+		}
+
+		private static void ThrowNonBooleanUtfSequence(in SequenceReader<byte> source, long position)
+		{
+			if (TryGetUtf8Unit(source, out var unit) == Utf8UnitStatus.Invalid)
+			{
+				JsonThrow.MalformedUtf8(unit, position);
+			}
+			else
+			{
+				JsonThrow.IsNotType(typeof(bool), unit, position);
+			}
+		}
+
+		private double DecodeNumber(in SequenceReader<byte> source, out int requestHint)
+		{
+			var start = source.Position;
+			var startOffset = source.Consumed;
+			var length = 0L;
+			// -? (0 | [1-9] \d*) (\. \d+ ([eE] [+-] \d+)? )?
+			// sign
+			if (source.IsNext(JsonNumberTokens.PlusMinusSigns, advancePast: true))
+			{
+				length++;
+			}
+
+			// 0
+			if (source.IsNext((byte)'0', advancePast: true))
+			{
+				length++;
+			}
+			// [1-9]
+			else if (source.IsNext(JsonNumberTokens.NonZeroDigits, advancePast: true))
+			{
+				length++;
+				// \d*
+				length += source.AdvancePastAny(JsonNumberTokens.Digits);
+			}
+			else
+			{
+				ThrowInvalidNumber(source);
+			}
+
+			// Check early for integer portion.
+			if (length > this.Options.MaxNumberLengthInBytes)
+			{
+				JsonThrow.TooLongNumber(length, this.Options.MaxNumberLengthInBytes, startOffset);
+			}
+
+			// (\. ...)?
+			if (source.IsNext((byte)'.', advancePast: true))
+			{
+				length++;
+
+				if (source.End)
+				{
+					requestHint = 1;
+					source.Rewind(length);
+					return default;
+				}
+
+				// \d+
+				length += ReadAtLeastOneDigits(source, out requestHint);
+				if (requestHint != 0)
+				{
+					source.Rewind(length);
+					return default;
+				}
+
+				// ([eE] ..)?
+				if (source.IsNext(JsonNumberTokens.ExponentialIndicators, advancePast: true))
+				{
+					// [+-]
+					if (source.IsNext(JsonNumberTokens.PlusMinusSigns, advancePast: true))
+					{
+						// \d+
+						length += ReadAtLeastOneDigits(source, out requestHint);
+						if (requestHint != 0)
+						{
+							source.Rewind(length);
+							return default;
+						}
+					}
+					else
+					{
+						ThrowInvalidNumber(source);
+					}
+				}
+			}
+
+			if (length > this.Options.MaxNumberLengthInBytes)
+			{
+				JsonThrow.TooLongNumber(length, this.Options.MaxNumberLengthInBytes, startOffset);
+			}
+
+			var readDirect = source.UnreadSpan.Length <= length;
+
+			var length32 = (int)length;
+			byte[]? arrayBuffer = default;
+			if (!readDirect && length > 32)
+			{
+				// length should be Int32 because MaxNumberLength is Int32 type.
+				arrayBuffer = this.Options.ByteBufferPool.Rent(length32);
+			}
+
+			try
+			{
+				Span<byte> buffer =
+					readDirect ?
+						default :
+						arrayBuffer ?? (stackalloc byte[length32]);
+				var number = GetSpan(source.Sequence.Slice(start, length32), buffer);
+
+				var shouldBeTrue = Utf8Parser.TryParse(number, out double result, out var shouldBeLength);
+				Debug.Assert(shouldBeTrue, "Utf8Parser.TryParse returns false!");
+				Debug.Assert(shouldBeLength == length, $"Utf8Parser.TryParse outputs ({shouldBeLength}:#,0) is not {length:#,0}!");
+				requestHint = 0;
+				source.Advance(length);
+				return result;
+			}
+			finally
+			{
+				if (arrayBuffer != null)
+				{
+					this.Options.ByteBufferPool.Return(arrayBuffer, this.Options.ClearsBuffer);
+				}
+			}
+		}
+
+		private static ReadOnlySpan<byte> GetSpan(in ReadOnlySequence<byte> source, Span<byte> buffer)
+		{
+			if (source.IsSingleSegment)
+			{
+				Debug.Assert(source.FirstSpan.Length == source.Length, "source.FirstSpan.Length == source.Length");
+				return source.FirstSpan;
+			}
+
+			Debug.Assert(source.Length == buffer.Length, "source.Length == buffer.Length");
+			source.CopyTo(buffer);
+			return buffer;
+		}
+
+		private static long ReadAtLeastOneDigits(in SequenceReader<byte> source, out int requestHint)
+		{
+			if (source.End)
+			{
+				requestHint = 1;
+				return default;
+			}
+
+			var decimalLength = source.AdvancePastAny(JsonNumberTokens.Digits);
+			if (decimalLength == 0)
+			{
+				ThrowInvalidNumber(source);
+			}
+
+			requestHint = 0;
+			return decimalLength;
+		}
+
+		private static void ThrowInvalidNumber(in SequenceReader<byte> source)
+		{
+			var position = source.Consumed;
+			if (TryGetUtf8Unit(source, out var unit) == Utf8UnitStatus.Valid)
+			{
+				JsonThrow.IsNotType(typeof(double), unit, position);
+			}
+			else
+			{
+				JsonThrow.MalformedUtf8(unit, position);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs b/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs
new file mode 100644
index 000000000..1eff27f97
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs
@@ -0,0 +1,139 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	partial class JsonDecoder
+	{
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Byte DecodeByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeByteCore(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private Byte DecodeByteCore(in SequenceReader<byte> source, out int requestHint)
+			=> (Byte)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override SByte DecodeSByte(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeSByteCore(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private SByte DecodeSByteCore(in SequenceReader<byte> source, out int requestHint)
+			=> (SByte)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int16 DecodeInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeInt16Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private Int16 DecodeInt16Core(in SequenceReader<byte> source, out int requestHint)
+			=> (Int16)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt16 DecodeUInt16(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeUInt16Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private UInt16 DecodeUInt16Core(in SequenceReader<byte> source, out int requestHint)
+			=> (UInt16)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int32 DecodeInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeInt32Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private Int32 DecodeInt32Core(in SequenceReader<byte> source, out int requestHint)
+			=> (Int32)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt32 DecodeUInt32(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeUInt32Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private UInt32 DecodeUInt32Core(in SequenceReader<byte> source, out int requestHint)
+			=> (UInt32)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Int64 DecodeInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeInt64Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private Int64 DecodeInt64Core(in SequenceReader<byte> source, out int requestHint)
+			=> (Int64)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override UInt64 DecodeUInt64(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeUInt64Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private UInt64 DecodeUInt64Core(in SequenceReader<byte> source, out int requestHint)
+			=> (UInt64)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Single DecodeSingle(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeSingleCore(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private Single DecodeSingleCore(in SequenceReader<byte> source, out int requestHint)
+			=> (Single)this.DecodeNumber(source, out requestHint);
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override Double DecodeDouble(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeDoubleCore(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private Double DecodeDoubleCore(in SequenceReader<byte> source, out int requestHint)
+			=> (Double)this.DecodeNumber(source, out requestHint);
+
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt b/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt
new file mode 100644
index 000000000..70674fd15
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt
@@ -0,0 +1,54 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	partial class JsonDecoder
+	{
+<#
+foreach (var type in
+	new []
+	{
+		"Byte",
+		"SByte",
+		"Int16",
+		"UInt16",
+		"Int32",
+		"UInt32",
+		"Int64",
+		"UInt64",
+		"Single",
+		"Double"
+	}
+)
+{
+#>
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override <#= type #> Decode<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		{
+			this.ReadTrivia(source, out _);
+			return this.Decode<#= type #>Core(source, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private <#= type #> Decode<#= type #>Core(in SequenceReader<byte> source, out int requestHint)
+			=> (<#= type #>)this.DecodeNumber(source, out requestHint);
+
+<#
+} // foreach (var type)
+#>
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs b/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs
new file mode 100644
index 000000000..c7c6fb4a5
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs
@@ -0,0 +1,46 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	public partial class JsonDecoder
+	{
+		public override void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default)
+			=> JsonThrow.DrainIsNotSupported(out requestHint);
+
+		public override void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var originalPosition = source.Consumed;
+
+			if(!this.DecodeItem(source, out var decodeItemResult, cancellationToken))
+			{
+				requestHint = (int)(decodeItemResult.RequestHint & Int32.MaxValue);
+				return;
+			}
+
+			switch (decodeItemResult.ElementType)
+			{
+				case ElementType.Array:
+				case ElementType.Map:
+				{
+					// Skip current collection with CollectionIterator.Drain()
+					if(!decodeItemResult.CollectionIterator.Drain(source, out requestHint))
+					{
+						source.Rewind(source.Consumed - originalPosition);
+						return;
+					}
+
+					break;
+				}
+			}
+
+			requestHint = 0;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Strings.cs b/src/MsgPack.Json/Json/JsonDecoder.Strings.cs
new file mode 100644
index 000000000..616a6f0aa
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.Strings.cs
@@ -0,0 +1,465 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Text;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	public partial class JsonDecoder
+	{
+		/// <inheritdoc />
+		public override bool GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			if (!this.GetRawStringCore(source, out var rawStringSequence, out requestHint, cancellationToken))
+			{
+				rawString = default;
+				return false;
+			}
+
+			if (rawStringSequence.IsSingleSegment)
+			{
+				rawString = rawStringSequence.FirstSpan;
+			}
+			else
+			{
+				// length should be Int32 because max length option is Int32 type.
+				Span<byte> result = new byte[(int)rawStringSequence.Length];
+				rawStringSequence.CopyTo(result);
+				rawString = result;
+			}
+
+			return true;
+		}
+
+		private bool GetRawStringCore(in SequenceReader<byte> source, out ReadOnlySequence<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
+		{ 
+			this.ReadTrivia(source, out _);
+			var startOffset = source.Consumed;
+
+			var quotation = this.ReadStringStart(source, out var delimiters, out requestHint);
+			if (requestHint != 0)
+			{
+				rawString = default;
+				return false;
+			}
+
+			var length = 0L;
+			var rawStringStart = source.Position;
+			// We accept unescaped charactors except quotation even if the value is '\0' because we can handle them correctly.
+			while (true)
+			{
+				cancellationToken.ThrowIfCancellationRequested();
+
+				if (!source.TryReadToAny(out ReadOnlySequence<byte> sequence, delimiters, advancePastDelimiter: false))
+				{
+					// EoF
+					requestHint = 1;
+					break;
+				}
+
+				if (sequence.Length + length > this.Options.MaxStringLengthInBytes)
+				{
+					Throw.StringLengthExceeded(source.Consumed - sequence.Length, sequence.Length + length, this.Options.MaxBinaryLengthInBytes);
+				}
+
+				length += (int)sequence.Length;
+
+				// Handle delimiter
+				source.TryRead(out var delimiter);
+				if (delimiter == quotation)
+				{
+					// End
+					requestHint = 0;
+					rawString = source.Sequence.Slice(rawStringStart, length);
+					return true;
+				}
+
+				// Decode escape sequence
+				if (source.End)
+				{
+					// EoF
+					requestHint = 2;
+					break;
+				}
+			}
+
+			// No closing quotation.
+			rawString = default;
+			source.Rewind(source.Consumed - startOffset);
+			return false;
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override string? DecodeNullableString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeStringCore(source, out requestHint, cancellationToken);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override string? DecodeString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeStringCore(source, out requestHint, cancellationToken);
+		}
+
+		private string? DecodeStringCore(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var startOffset = source.Consumed;
+
+			var quotation = this.ReadStringStart(source, out var delimiters, out requestHint);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			var length = 0L;
+			using (var result = new StringBuilderBufferWriter(new StringBuilder(), this.Options))
+			{
+				// We accept unescaped charactors except quotation even if the value is '\0' because we can handle them correctly.
+				while (true)
+				{
+					cancellationToken.ThrowIfCancellationRequested();
+
+					if (!source.TryReadToAny(out ReadOnlySequence<byte> sequence, delimiters, advancePastDelimiter: false))
+					{
+						// EoF
+						requestHint = 1;
+						source.Rewind(source.Consumed - startOffset);
+						break;
+					}
+
+					if (sequence.Length + length > this.Options.MaxStringLengthInBytes)
+					{
+						Throw.StringLengthExceeded(source.Consumed - sequence.Length, sequence.Length + length, this.Options.MaxBinaryLengthInBytes);
+					}
+
+					// Copy & UTF8 decoding existing.
+					Encoding.UTF8.GetChars(sequence, result);
+					length += (int)sequence.Length;
+
+					// Handle delimiter
+					source.TryRead(out var delimiter);
+					if (delimiter == quotation)
+					{
+						// End
+						requestHint = 0;
+						return result.ToString();
+					}
+
+					// Decode escape sequence
+					if (source.End)
+					{
+						// EoF
+						requestHint = 2;
+						break;
+					}
+
+					if (!source.IsNext((byte)'u', advancePast: true))
+					{
+						DecodeSpetialEscapeSequence(source, result);
+						length += 2;
+					}
+					else
+					{
+						DecodeUnicodeEscapceSequence(source, result, out requestHint);
+						if (requestHint != 0)
+						{
+							source.Rewind(source.Consumed - startOffset);
+							return default;
+						}
+
+						length += 6;
+					}
+				}
+			}
+
+			// No closing quotation.
+			return default;
+		}
+
+		private byte ReadStringStart(in SequenceReader<byte> source, out ReadOnlySpan<byte> delimiters, out int requestHint)
+		{
+			if (source.End)
+			{
+				requestHint = 2;
+				delimiters = default;
+				return default;
+			}
+
+			if (source.IsNext((byte)'"', advancePast: false))
+			{
+				delimiters = JsonStringTokens.DoubleQuotationDelimiters;
+			}
+			else
+			{
+				if ((this.Options.ParseOptions & JsonParseOptions.AllowSingleQuotationString) != 0)
+				{
+					// ['"]
+					if (source.IsNext((byte)'\'', advancePast: false))
+					{
+						delimiters = JsonStringTokens.SingleQuotationDelimiters;
+					}
+					else
+					{
+						JsonThrow.IsNotStringStart(source.Consumed, JsonStringTokens.AnyQuotations);
+						// never
+						delimiters = default;
+					}
+				}
+				else
+				{
+					JsonThrow.IsNotStringStart(source.Consumed, JsonStringTokens.DoubleQuotation);
+					// never
+					delimiters = default;
+				}
+			}
+
+			source.TryRead(out var quotation);
+			requestHint = 0;
+			return quotation;
+		}
+
+		private static void DecodeSpetialEscapeSequence(in SequenceReader<byte> source, StringBuilderBufferWriter result)
+		{
+			source.TryPeek(out var escaped);
+			// Handle known escape sequence
+			var index = escaped - JsonStringTokens.UnescapedCharactorsOffset;
+			var unescaped = Byte.MaxValue;
+			if (index >= 0 && index < JsonStringTokens.UnescapedCharactors.Length)
+			{
+				unescaped = JsonStringTokens.UnescapedCharactors[index];
+			}
+
+			if (unescaped >= 0x80)
+			{
+				JsonThrow.InvalidEscapeSequence(source.Consumed, escaped);
+			}
+
+			result.AppendUtf16CodePoint(unescaped);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static void DecodeUnicodeEscapceSequence(SequenceReader<byte> source, StringBuilderBufferWriter result, out int requestHint)
+		{
+			Span<byte> buffer = stackalloc byte[4];
+			if (!source.TryCopyTo(buffer))
+			{
+				requestHint = buffer.Length - (int)source.Remaining;
+				return;
+			}
+
+			if (!Utf8Parser.TryParse(buffer, out int codePointOrHighSurrogate, out var consumed, standardFormat: 'X'))
+			{
+				JsonThrow.InvalidUnicodeEscapeSequence(source.Consumed - 2, buffer);
+			}
+
+			Debug.Assert(consumed == 4, $"consumed ({consumed}) == 4 for '{BitConverter.ToString(buffer.ToArray())}'");
+
+			var positionOf1stSurrogate = source.Consumed - 2;
+			if (Unicode.IsLowSurrogate(codePointOrHighSurrogate))
+			{
+				// 1st surrogte must be high surrogate.
+				JsonThrow.OrphanSurrogate(positionOf1stSurrogate, codePointOrHighSurrogate);
+			}
+
+			source.Advance(consumed);
+			result.AppendUtf16CodePoint(codePointOrHighSurrogate);
+
+			if (Unicode.IsHighSurrogate(codePointOrHighSurrogate))
+			{
+				if (source.Remaining < 7)
+				{
+					requestHint = 7 - (int)source.Remaining;
+					return;
+				}
+
+				// Search lower surrogate
+				if (!source.IsNext((byte)'\\', advancePast: true))
+				{
+					// No paired low surrogate.
+					JsonThrow.OrphanSurrogate(positionOf1stSurrogate, codePointOrHighSurrogate);
+				}
+
+				if (!source.IsNext((byte)'u', advancePast: true))
+				{
+					// No paired low surrogate.
+					JsonThrow.OrphanSurrogate(positionOf1stSurrogate, codePointOrHighSurrogate);
+				}
+
+				source.Sequence.Slice(source.Consumed, 4).CopyTo(buffer);
+				if (!Utf8Parser.TryParse(buffer, out int shouldBeLowSurrogate, out consumed, standardFormat: 'X'))
+				{
+					JsonThrow.InvalidUnicodeEscapeSequence(source.Consumed, buffer);
+				}
+
+				if (!Unicode.IsLowSurrogate(shouldBeLowSurrogate))
+				{
+					// No paired low surrogate.
+					JsonThrow.OrphanSurrogate(positionOf1stSurrogate, codePointOrHighSurrogate);
+				}
+
+				Debug.Assert(consumed == 4, $"consumed ({consumed}) == 4 for '{BitConverter.ToString(buffer.ToArray())}'");
+
+				source.Advance(consumed);
+				result.AppendUtf16CodePoint(shouldBeLowSurrogate);
+			}
+
+			requestHint = 0;
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override byte[]? DecodeNullableBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			this.ReadTrivia(source, out _);
+			if (this.TryReadNull(source))
+			{
+				requestHint = 0;
+				return null;
+			}
+
+			return this.DecodeBinaryCore(source, out requestHint, cancellationToken);
+		}
+
+		/// <inheritdoc />
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override byte[]? DecodeBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			this.ReadTrivia(source, out _);
+			return this.DecodeBinaryCore(source, out requestHint, cancellationToken);
+		}
+
+		private byte[]? DecodeBinaryCore(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		{
+			var startOffset = source.Consumed;
+
+			var quotation = this.ReadStringStart(source, out _, out requestHint);
+			if (requestHint != 0)
+			{
+				return default;
+			}
+
+			if (!source.TryReadTo(out ReadOnlySequence<byte> sequence, quotation, advancePastDelimiter: true))
+			{
+				// EoF
+				requestHint = 1;
+				source.Rewind(source.Consumed - startOffset);
+				return default;
+			}
+
+			if (sequence.Length > this.Options.MaxBinaryLengthInBytes)
+			{
+				Throw.BinaryLengthExceeded(startOffset + 1, sequence.Length, this.Options.MaxBinaryLengthInBytes);
+			}
+
+			var resultLength = 0;
+			var inputBuffer = sequence.IsSingleSegment ? null : this.Options.ByteBufferPool.Rent(this.Options.MaxByteBufferLength);
+			try
+			{
+				var outputBuffer = this.Options.ByteBufferPool.Rent(this.Options.MaxByteBufferLength);
+				try
+				{
+					ReadOnlySpan<byte> inputSpan = sequence.FirstSpan;
+					Span<byte> outputSpan = outputBuffer;
+					var status = OperationStatus.DestinationTooSmall;
+					while (true)
+					{
+						status = Base64.DecodeFromUtf8(inputSpan, outputSpan, out var bytesConsumed, out var bytesWritten, isFinalBlock: sequence.IsSingleSegment);
+						inputSpan = inputSpan.Slice(bytesConsumed);
+						outputSpan = outputSpan.Slice(bytesWritten);
+
+						resultLength += bytesWritten;
+						switch (status)
+						{
+							case OperationStatus.Done:
+							{
+								// OK
+								var result = new byte[resultLength];
+								unsafe
+								{
+									fixed (byte* pBuffer = outputBuffer)
+									fixed (byte* pResult = result)
+									{
+										Buffer.MemoryCopy(pBuffer, pResult, result.Length, resultLength);
+									}
+								}
+
+								return result;
+							}
+							case OperationStatus.DestinationTooSmall:
+							{
+								// Realloc buffer and set span head.
+
+								var newBuffer = this.Options.ByteBufferPool.Rent(outputBuffer.Length * 2);
+								unsafe
+								{
+									fixed (byte* pBuffer = outputBuffer)
+									fixed (byte* pNewBuffer = newBuffer)
+									{
+										Buffer.MemoryCopy(pBuffer, pNewBuffer, outputBuffer.Length, outputBuffer.Length);
+									}
+								}
+
+								outputSpan = newBuffer.AsSpan(outputBuffer.Length - outputSpan.Length);
+								this.Options.ByteBufferPool.Return(outputBuffer, this.Options.ClearsBuffer);
+								outputBuffer = newBuffer;
+								break;
+							}
+							case OperationStatus.NeedMoreData:
+							{
+								// In this case, ReadOnlySequence<byte> is multi segment.
+								Debug.Assert(!sequence.IsSingleSegment, "!sequence.IsSingleSegment");
+								Debug.Assert(inputBuffer != null, "inputBuffer != null");
+
+								// Realloc input span.
+
+								var consumed = inputBuffer.Length - inputSpan.Length;
+
+								sequence = sequence.Slice(consumed);
+								var newInputSpanLength = (int)Math.Min(inputBuffer.Length, sequence.Length);
+								sequence.Slice(0, newInputSpanLength).CopyTo(inputBuffer);
+								inputSpan = inputBuffer.AsSpan(0, newInputSpanLength);
+								break;
+							}
+							default:
+							{
+								Debug.Assert(status == OperationStatus.InvalidData, $"status ({status}) == OperationStatus.InvalidData");
+								JsonThrow.InvalidBase64(startOffset);
+								// never
+								return default;
+							}
+						}
+					}
+				}
+				finally
+				{
+					this.Options.ByteBufferPool.Return(outputBuffer, this.Options.ClearsBuffer);
+				}
+			}
+			finally
+			{
+				if (!(inputBuffer is null))
+				{
+					this.Options.ByteBufferPool.Return(inputBuffer, this.Options.ClearsBuffer);
+				}
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.cs b/src/MsgPack.Json/Json/JsonDecoder.cs
new file mode 100644
index 000000000..87fc25bf5
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoder.cs
@@ -0,0 +1,166 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		A decoder for JSON format.
+	/// </summary>
+	public abstract partial class JsonDecoder : Decoder<NullExtensionType>
+	{
+		private static readonly FormatFeatures JsonFormatFeatures =
+			new FormatFeaturesBuilder
+			{
+				CanCountCollectionItems = false,
+				CanSpecifyStringEncoding = false,
+				SupportsExtensionTypes = false,
+				IsContextful = true
+			}.Build();
+
+		public new JsonDecoderOptions Options { get; }
+
+		protected JsonDecoder(JsonDecoderOptions options)
+			: base(options, JsonFormatFeatures)
+		{
+			this.Options = options;
+		}
+
+		public static JsonDecoder Create(JsonDecoderOptions options)
+		{
+			if ((options?.ParseOptions).GetValueOrDefault() == JsonParseOptions.None)
+			{
+				return new SimpleJsonDecoder(options!);
+			}
+			else
+			{
+				return new FlexibleJsonDecoder(options!);
+			}
+		}
+
+		private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> source, out ReadOnlySequence<byte> unit)
+		{
+			if (source.UnreadSpan.IsEmpty)
+			{
+				unit = default;
+				return Utf8UnitStatus.TooShort;
+			}
+
+			var utf80 = source.UnreadSpan[0];
+			if ((utf80 & 0b_1000_0000) == 0)
+			{
+				// 1byte
+				unit = source.Sequence.Slice(source.Consumed, 1);
+				return Utf8UnitStatus.Valid;
+			}
+			else if ((utf80 & 0b_1110_0000) == 0b_1100_0000)
+			{
+				Span<byte> utf8 = stackalloc byte[2];
+				if (!source.TryCopyTo(utf8))
+				{
+					unit = source.Sequence.Slice(source.Consumed, source.Remaining);
+					return Utf8UnitStatus.TooShort;
+				}
+
+				unit = source.Sequence.Slice(source.Consumed, 2);
+
+				// 2 bytes, 5 + 6 bits
+				var bits1 = utf8[0] & 0b_0001_1111;
+				var bits2 = utf8[1] & 0b_0011_1111;
+
+				if ((bits1 & 0b_1_1110) == 0
+					|| (utf8[1] & 0b_1100_0000) != 0b_1000_0000)
+				{
+					return Utf8UnitStatus.Invalid;
+				}
+
+				return Utf8UnitStatus.Valid;
+			}
+			else if ((utf80 & 0b_1111_0000) == 0b_1110_0000)
+			{
+				Span<byte> utf8 = stackalloc byte[3];
+				if (!source.TryCopyTo(utf8))
+				{
+					unit = source.Sequence.Slice(source.Consumed, source.Remaining);
+					return Utf8UnitStatus.TooShort;
+				}
+
+				unit = source.Sequence.Slice(source.Consumed, 3);
+
+				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
+					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000)
+				{
+					return Utf8UnitStatus.Invalid;
+				}
+
+				// 3 bytes, 4 + 6 + 6 bits
+				var bits1 = utf8[0] & 0b_0000_1111;
+				var bits2 = utf8[1] & 0b_0011_1111;
+				var bits3 = utf8[2] & 0b_0011_1111;
+
+				ushort codePoint = (ushort)((bits1 << 12) | (bits2 << 6) | bits3);
+
+				if ((codePoint & 0b_1111_100000_000000) == 0 || !Rune.IsValid(codePoint))
+				{
+					return Utf8UnitStatus.Invalid;
+				}
+
+				return Utf8UnitStatus.Valid;
+			}
+			else if ((utf80 & 0b_1111_1000) == 0b_1111_0000)
+			{
+				Span<byte> utf8 = stackalloc byte[4];
+				if (!source.TryCopyTo(utf8))
+				{
+					unit = source.Sequence.Slice(source.Consumed, source.Remaining);
+					return Utf8UnitStatus.TooShort;
+				}
+
+				unit = source.Sequence.Slice(source.Consumed, 4);
+
+				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
+					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000
+					|| (utf8[3] & 0b_1100_0000) != 0b_1000_0000)
+				{
+					return Utf8UnitStatus.Invalid;
+				}
+
+				// 4 bytes, 3 + 6 + 6 + 6 bits
+				var bits1 = (utf8[0] & 0b_0000_0111) << 18;
+				var bits2 = (utf8[1] & 0b_0011_1111) << 12;
+				var bits3 = (utf8[2] & 0b_0011_1111) << 6;
+				var bits4 = (utf8[3] & 0b_0011_1111);
+
+				int codePoint = ((bits1 << 18) | (bits2 << 12) | (bits1 << 6) | bits4);
+
+				if ((codePoint & 0b_111_110000_000000_000000) == 0)
+				{
+					return Utf8UnitStatus.Invalid;
+				}
+
+				return Utf8UnitStatus.Valid;
+			}
+			else
+			{
+				unit = source.Sequence.Slice(source.Consumed, 1);
+				return Utf8UnitStatus.Invalid;
+			}
+		}
+
+		protected abstract void ReadTrivia(in SequenceReader<byte> source, out ReadOnlySequence<byte> trivia);
+
+		protected abstract bool TryReadNull(in SequenceReader<byte> source);
+
+		protected enum Utf8UnitStatus
+		{
+			TooShort = 0,
+			Valid = 1,
+			Invalid = 2
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoderOptions.cs b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
new file mode 100644
index 000000000..eb4e36dbc
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
@@ -0,0 +1,22 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines decoder options for <see cref="JsonDecoder"/>.
+	/// </summary>
+	public class JsonDecoderOptions : DecoderOptions
+	{
+		public JsonParseOptions ParseOptions { get; }
+
+		public JsonDecoderOptions(JsonDecoderOptionsBuilder builder)
+			: base(builder)
+		{
+			this.ParseOptions = builder.ParseOptions;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs b/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs
new file mode 100644
index 000000000..2ac9b8d4a
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs
@@ -0,0 +1,20 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		A builder object for immutable <see cref="JsonDecoderOptions"/>.
+	/// </summary>
+	public class JsonDecoderOptionsBuilder : DecoderOptionsBuilder
+	{
+		public JsonParseOptions ParseOptions { get; set; }
+
+		public JsonDecoderOptionsBuilder() { }
+
+		public JsonDecoderOptions Build() => new JsonDecoderOptions(this);
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonEncoder.cs b/src/MsgPack.Json/Json/JsonEncoder.cs
index 721247c94..ab21260ad 100644
--- a/src/MsgPack.Json/Json/JsonEncoder.cs
+++ b/src/MsgPack.Json/Json/JsonEncoder.cs
@@ -1,137 +1,49 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
 using System;
 using System.Buffers;
 using System.Buffers.Text;
-using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 using MsgPack.Internal;
 
 namespace MsgPack.Json
 {
-	internal static class JsonTokens
-	{
-		public static readonly ReadOnlyMemory<byte> Null = new[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
-		public static readonly ReadOnlyMemory<byte> True = new[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e' };
-		public static readonly ReadOnlyMemory<byte> False = new[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e' };
-		public static readonly ReadOnlyMemory<byte> ArrayStart = new[] { (byte)'[' };
-		public static readonly ReadOnlyMemory<byte> ArrayEnd = new[] { (byte)']' };
-		public static readonly ReadOnlyMemory<byte> MapStart = new[] { (byte)'{' };
-		public static readonly ReadOnlyMemory<byte> MapEnd = new[] { (byte)'}' };
-		public static readonly ReadOnlyMemory<byte> Whitespace = new[] { (byte)' ' };
-		public static readonly ReadOnlyMemory<byte> Comma = new[] { (byte)',' };
-		public static readonly ReadOnlyMemory<byte> Colon = new[] { (byte)':' };
-		public static readonly ReadOnlyMemory<byte> Quatation = new[] { (byte)'"' };
-	}
-
-	internal static class JsonCharactor
-	{
-		public static readonly ReadOnlyMemory<byte> MustBeEscaped = new int[] { '\\', '"' }.Concat(Enumerable.Range(0, 0x1F)).Select(i => unchecked((byte)i)).ToArray();
-		public static readonly ReadOnlyMemory<byte> ShouldBeEscaped = new[] { (byte)'/', (byte)'\'', (byte)'<', (byte)'>', (byte)'&' };
-		public static readonly ReadOnlyMemory<byte> CarriageReturn = new[] { (byte)'\r' };
-		public static readonly ReadOnlyMemory<byte> LineFeed = new[] { (byte)'\n' };
-	}
-
-	internal static class JsonEscapeSequence
-	{
-		public static readonly ReadOnlyMemory<byte> Unicode = new[] { (byte)'\\', (byte)'u' };
-
-		public static readonly ReadOnlyMemory<byte> ReverseSolidous = new[] { (byte)'\\', (byte)'\\' };
-		public static readonly ReadOnlyMemory<byte> Quatation = new[] { (byte)'\\', (byte)'"' };
-		public static readonly ReadOnlyMemory<byte> Tab = new[] { (byte)'\\', (byte)'t' };
-		public static readonly ReadOnlyMemory<byte> CarriageReturn = new[] { (byte)'\\', (byte)'r' };
-		public static readonly ReadOnlyMemory<byte> LineFeed = new[] { (byte)'\\', (byte)'n' };
-		public static readonly ReadOnlyMemory<byte> BackSpace = new[] { (byte)'\\', (byte)'b' };
-		public static readonly ReadOnlyMemory<byte> FormFeed = new[] { (byte)'\\', (byte)'f' };
-
-		public static readonly StandardFormat UnicodeFormat = new StandardFormat('X', 4);
-	}
-
-	public enum NaNHandling
-	{
-		Default = 0,
-		Null = 1,
-		Error = 2,
-		Custom = 3
-	}
-
-	public enum InfinityHandling
+	/// <summary>
+	///		An encoder for JSON format.
+	/// </summary>
+	public sealed class JsonEncoder : Encoder<NullExtensionType>
 	{
-		Default = 0,
-		MinMax = 1,
-		Error = 2,
-		Custom = 3
-	}
-
-	[Flags]
-	public enum JsonParseOptions
-	{
-		None = 0,
-		AllowHashSingleLineComment = 0x1,
-		AllowDoubleSolidousSingleLineComment = 0x2,
-		AllowUnicodeWhitespace = 0x10,
-		AllowAllTrivias = 0xFF,
-		AllowNaN = 0x100,
-		AllowInfinity = 0x200,
-		AllowUndefined = 0x1000,
-		AllowIrregalValues = 0xFF00,
-		AllowEqualSignSeparator = 0x10000,
-		AllowSemicolonDelimiter = 0x20000,
-		AllowExtraComma = 0x40000,
-		AllowSingleQuatationString = 0x100000,
-		AllowUnescapedNewLineInString = 0x200000,
-		AllowUnescapedTabInString = 0x400000,
-		AllowWellknownSyntaxErrors = 0xFF0000,
-		AllowAllErrors = unchecked((int)0xFFFFFFFF)
-	}
-
-	public class JsonEncoderOptionsBase
-	{
-#warning TODO: Options
-	}
-
-	public class JsonEncoderBase : Internal.Encoder
-	{
-#warning TODO: Abstract
-#warning TODO: tuning
-		private static readonly Func<float, Memory<byte>, int> s_singleFormatter =
-			(v, m) => Utf8Formatter.TryFormat(v, m.Span, out var used) ? used : -1;
-		private static readonly Func<float, Memory<byte>, int> s_defaultSingleNanFormatter =
-			(_, m) => WriteNull(m.Span);
-		private static readonly Func<float, Memory<byte>, int> s_defaultSingleInfinityFormatter =
-			(v, m) => Utf8Formatter.TryFormat(v < 0 ? Single.MinValue : Single.MaxValue, m.Span, out var used) ? used : -1;
-
-		private static readonly Func<double, Memory<byte>, int> s_doubleFormatter =
-			(v, m) => Utf8Formatter.TryFormat(v, m.Span, out var used) ? used : -1;
-		private static readonly Func<double, Memory<byte>, int> s_defaultDoubleNanFormatter =
-			(_, m) => WriteNull(m.Span);
-		private static readonly Func<double, Memory<byte>, int> s_defaultDoubleInfinityFormatter =
-			(v, m) => Utf8Formatter.TryFormat(v < 0 ? Single.MinValue : Single.MaxValue, m.Span, out var used) ? used : -1;
-
-		private readonly Func<float, Memory<byte>, int> _singleInfinityFormatter;
-		private readonly Func<float, Memory<byte>, int> _singleNanFormatter;
-		private readonly Func<double, Memory<byte>, int> _doubleInfinityFormatter;
-		private readonly Func<double, Memory<byte>, int> _doubleNanFormatter;
-		private readonly bool _doIndent;
-		private readonly byte[] _indentString;
-		private readonly byte[] _newLine;
-		private readonly ReadOnlyMemory<byte> _toBeEscaped;
-
-		private int _indentLevel;
-
-#warning TODO: Options
-		protected JsonEncoderBase()
+		private readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> _singleInfinityFormatter;
+		private readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> _singleNanFormatter;
+		private readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> _doubleInfinityFormatter;
+		private readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> _doubleNanFormatter;
+		private readonly ReadOnlyMemory<byte> _indentChars;
+		private readonly ReadOnlyMemory<byte> _newLineChars;
+		private readonly ReadOnlyMemory<byte> _escapeTargetChars1Byte;
+		private readonly ReadOnlyMemory<ushort> _escapeTargetChars2Byte;
+		private readonly ReadOnlyMemory<int> _escapeTargetChars4Byte;
+		private readonly bool _isPrettyPrint;
+		private readonly JsonEncoderOptions _options;
+
+		public JsonEncoder(JsonEncoderOptions options)
+			: base(options)
 		{
-			this._singleInfinityFormatter = s_defaultSingleInfinityFormatter;
-			this._singleNanFormatter = s_defaultSingleNanFormatter;
-			this._doubleInfinityFormatter = s_defaultDoubleInfinityFormatter;
-			this._doubleNanFormatter = s_defaultDoubleNanFormatter;
-			this._doIndent = false;
-			this._indentString = new[] { (byte)' ', (byte)' ' };
-			this._newLine = new[] { (byte)'\n' };
-			this._toBeEscaped = JsonCharactor.MustBeEscaped;
+			this._options = options;
+			this._singleInfinityFormatter = options.SingleInfinityFormatter;
+			this._singleNanFormatter = options.SingleNaNFormatter;
+			this._doubleInfinityFormatter = options.DoubleInfinityFormatter;
+			this._doubleNanFormatter = options.DoubleNaNFormatter;
+			this._indentChars = options.IndentChars;
+			this._newLineChars = options.NewLineChars;
+			this._isPrettyPrint = options.IsPrettyPrint;
+			this._escapeTargetChars1Byte = options.EscapeTargetChars1Byte;
+			this._escapeTargetChars2Byte = options.EscapeTargetChars2Byte;
+			this._escapeTargetChars4Byte = options.EscapeTargetChars4Byte;
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
@@ -142,13 +54,15 @@ private static int WriteNull(Span<byte> span)
 				return -1;
 			}
 
-			JsonTokens.Null.Span.CopyTo(span);
+			JsonTokens.Null.CopyTo(span);
 			return 4;
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void Encode(int value, IBufferWriter<byte> buffer)
+		public override void EncodeInt32(int value, IBufferWriter<byte> buffer)
 		{
+			buffer = EnsureNotNull(buffer);
+
 			var span = buffer.GetSpan();
 			while (true)
 			{
@@ -165,8 +79,10 @@ public override void Encode(int value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void Encode(long value, IBufferWriter<byte> buffer)
+		public override void EncodeUInt32(uint value, IBufferWriter<byte> buffer)
 		{
+			buffer = EnsureNotNull(buffer);
+
 			var span = buffer.GetSpan();
 			while (true)
 			{
@@ -183,22 +99,16 @@ public override void Encode(long value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void Encode(float value, IBufferWriter<byte> buffer)
+		public override void EncodeInt64(long value, IBufferWriter<byte> buffer)
 		{
-			var formatter =
-				Single.IsNaN(value) ?
-				this._singleNanFormatter :
-				Single.IsInfinity(value) ?
-				this._singleInfinityFormatter :
-				s_singleFormatter;
+			buffer = EnsureNotNull(buffer);
 
-			var memory = buffer.GetMemory();
+			var span = buffer.GetSpan();
 			while (true)
 			{
-				var used = formatter(value, memory);
-				if (used < 0)
+				if (!Utf8Formatter.TryFormat(value, span, out var used))
 				{
-					memory = buffer.GetMemory(memory.Length * 2);
+					span = buffer.GetSpan(span.Length * 2);
 				}
 				else
 				{
@@ -209,22 +119,16 @@ public override void Encode(float value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void Encode(double value, IBufferWriter<byte> buffer)
+		public override void EncodeUInt64(ulong value, IBufferWriter<byte> buffer)
 		{
-			var formatter =
-				Double.IsNaN(value) ?
-				this._doubleNanFormatter :
-				Double.IsInfinity(value) ?
-				this._doubleInfinityFormatter :
-				s_doubleFormatter;
+			buffer = EnsureNotNull(buffer);
 
-			var memory = buffer.GetMemory();
+			var span = buffer.GetSpan();
 			while (true)
 			{
-				var used = formatter(value, memory);
-				if (used < 0)
+				if (!Utf8Formatter.TryFormat(value, span, out var used))
 				{
-					memory = buffer.GetMemory(memory.Length * 2);
+					span = buffer.GetSpan(span.Length * 2);
 				}
 				else
 				{
@@ -235,106 +139,152 @@ public override void Encode(double value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void Encode(bool value, IBufferWriter<byte> buffer)
+		public override void EncodeSingle(float value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
+			var formatter =
+				Single.IsNaN(value) ?
+				this._singleNanFormatter :
+				Single.IsInfinity(value) ?
+				this._singleInfinityFormatter :
+				JsonFormatter.Format;
+			formatter(value, buffer, this._options);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeDouble(double value, IBufferWriter<byte> buffer)
 		{
+			buffer = EnsureNotNull(buffer);
+
+			var formatter =
+				Double.IsNaN(value) ?
+				this._doubleNanFormatter :
+				Double.IsInfinity(value) ?
+				this._doubleInfinityFormatter :
+				JsonFormatter.Format;
+			formatter(value, buffer, this._options);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public override void EncodeBoolean(bool value, IBufferWriter<byte> buffer)
+		{
+			buffer = EnsureNotNull(buffer);
+
 			if (value)
 			{
-				buffer.Write(JsonTokens.True.Span);
+				buffer.Write(JsonTokens.True);
 			}
 			else
 			{
-				buffer.Write(JsonTokens.False.Span);
+				buffer.Write(JsonTokens.False);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public override void EncodeNull(IBufferWriter<byte> buffer)
-			=> buffer.Write(JsonTokens.Null.Span);
+			=> buffer.Write(JsonTokens.Null);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		protected void WriteIndent(IBufferWriter<byte> buffer)
+		private void WriteIndent(IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			if (this._doIndent)
+			buffer = EnsureNotNull(buffer);
+
+			if (this._isPrettyPrint)
 			{
-				buffer.Write(this._newLine);
-				for (var i = 0; i < this._indentLevel; i++)
+				buffer.Write(this._newLineChars.Span);
+				for (var i = 0; i < collectionContext.CurrentDepth; i++)
 				{
-					buffer.Write(this._indentString);
+					buffer.Write(this._indentChars.Span);
 				}
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayStart(uint length, IBufferWriter<byte> buffer)
+		public override void EncodeArrayStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer.Write(JsonTokens.ArrayStart.Span);
-			this._indentLevel++;
+			buffer = EnsureNotNull(buffer);
+
+			buffer.Write(JsonTokens.ArrayStart);
+			collectionContext.IncrementDepth();
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayEnd(uint length, IBufferWriter<byte> buffer)
+		public override void EncodeArrayEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			this._indentLevel--;
-			this.WriteIndent(buffer);
-			buffer.Write(JsonTokens.ArrayEnd.Span);
+			buffer = EnsureNotNull(buffer);
+
+			collectionContext.DecrementDepth();
+			this.WriteIndent(buffer, collectionContext);
+			buffer.Write(JsonTokens.ArrayEnd);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayItemStart(uint index, IBufferWriter<byte> buffer)
+		public override void EncodeArrayItemStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			this.WriteIndent(buffer);
+			buffer = EnsureNotNull(buffer);
+
+			this.WriteIndent(buffer, collectionContext);
 			if (index > 0)
 			{
-				buffer.Write(JsonTokens.Comma.Span);
+				buffer.Write(JsonTokens.Comma);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayItemEnd(uint index, IBufferWriter<byte> buffer) { }
+		public override void EncodeArrayItemEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapStart(uint length, IBufferWriter<byte> buffer)
+		public override void EncodeMapStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer.Write(JsonTokens.MapStart.Span);
-			this._indentLevel++;
+			buffer = EnsureNotNull(buffer);
+
+			buffer.Write(JsonTokens.MapStart);
+			collectionContext.IncrementDepth();
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapEnd(uint length, IBufferWriter<byte> buffer)
+		public override void EncodeMapEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			this._indentLevel--;
-			this.WriteIndent(buffer);
-			buffer.Write(JsonTokens.MapEnd.Span);
+			buffer = EnsureNotNull(buffer);
+
+			collectionContext.DecrementDepth();
+			this.WriteIndent(buffer, collectionContext);
+			buffer.Write(JsonTokens.MapEnd);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapKeyStart(uint index, IBufferWriter<byte> buffer)
+		public override void EncodeMapKeyStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			this.WriteIndent(buffer);
+			buffer = EnsureNotNull(buffer);
+
+			this.WriteIndent(buffer, collectionContext);
 			if (index > 0)
 			{
-				buffer.Write(JsonTokens.Comma.Span);
+				buffer.Write(JsonTokens.Comma);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapKeyEnd(uint index, IBufferWriter<byte> buffer) { }
+		public override void EncodeMapKeyEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapValueStart(uint index, IBufferWriter<byte> buffer)
+		public override void EncodeMapValueStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer.Write(JsonTokens.Colon.Span);
-			if (this._doIndent)
+			buffer = EnsureNotNull(buffer);
+
+			buffer.Write(JsonTokens.Colon);
+			if (this._isPrettyPrint)
 			{
-				buffer.Write(JsonTokens.Whitespace.Span);
+				buffer.Write(JsonTokens.Whitespace);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapValueEnd(uint index, IBufferWriter<byte> buffer) { }
+		public override void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static ReadOnlyMemory<byte> GetEscapeSequence(byte c, bool newLineAllowed)
+		private static ReadOnlySpan<byte> GetEscapeSequence(byte c, bool newLineAllowed)
 		{
 			switch (c)
 			{
@@ -381,137 +331,224 @@ private static ReadOnlyMemory<byte> GetEscapeSequence(byte c, bool newLineAllowe
 			}
 
 			// Use \uXXXX
-			return ReadOnlyMemory<byte>.Empty;
+			return ReadOnlySpan<byte>.Empty;
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer)
+		public override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
-			buffer.Write(JsonTokens.Quatation.Span);
+			buffer = EnsureNotNull(buffer);
+
+			buffer.Write(JsonTokens.Quatation);
 
-			this.EncodeStringBody(encodedValue, buffer);
+			this.EncodeStringBody(encodedValue, 0, buffer);
 
 			// End quot
-			buffer.Write(JsonTokens.Quatation.Span);
+			buffer.Write(JsonTokens.Quatation);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private void EncodeStringBody(ReadOnlySpan<byte> encodedValue, IBufferWriter<byte> buffer)
+		private void EncodeStringBody(ReadOnlySpan<byte> encodedValue, long position, IBufferWriter<byte> buffer)
 		{
 			var source = encodedValue;
-			var sink = buffer.GetSpan(encodedValue.Length);
 			while (!source.IsEmpty)
 			{
-				var moreBytes = this.EscapeStringContent(source, sink, out var sourceUsed, out var sinkUsed);
-				buffer.Advance(sinkUsed);
-				source = source.Slice(sourceUsed);
-				sink = buffer.GetSpan(moreBytes);
+				this.EscapeUtf8(ref source, ref position, buffer);
 			}
 		}
 
-		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private int EscapeStringContent(ReadOnlyMemory<byte> source, Memory<byte> sink, out int sourceUsed, out int sinkUsed)
-			=> this.EscapeStringContent(source.Span, sink.Span, out sourceUsed, out sinkUsed);
-
-		private int EscapeStringContent(ReadOnlySpan<byte> source, Span<byte> sink, out int sourceUsed, out int sinkUsed)
+		private void EscapeUtf8(ref ReadOnlySpan<byte> utf8, ref long position, IBufferWriter<byte> buffer)
 		{
-			sourceUsed = 0;
-			sinkUsed = 0;
+			if (utf8.IsEmpty)
+			{
+				return;
+			}
+
+			if ((utf8[0] & 0b_1000_0000) == 0)
+			{
+				// 1 byte, 7bits
+				byte codePoint = (byte)(utf8[0] & 0b_0111_1111);
+
+				if (this._escapeTargetChars1Byte.Span.Contains(codePoint)
+					|| codePoint < 0x09 // Control chars must be escaped except horizontal tab
+					|| (this._options.EscapesHorizontalTab && codePoint == 0x09)
+					|| (codePoint > 0x09 && codePoint < 0x20) // Control chars must be escaped except horizontal tab
+					|| codePoint >= 0x7F  // Control chars must be escaped (DEL)
+					)
+				{
+					var escapeSequence = GetEscapeSequence(codePoint, newLineAllowed: false);
+					if (escapeSequence.IsEmpty)
+					{
+						EscapeCodePoint(codePoint, buffer);
+					}
+					else
+					{
+						buffer.Write(escapeSequence);
+					}
+				}
+				else
+				{
+					buffer.Write(utf8.Slice(0, 1));
+				}
 
-			while (!sink.IsEmpty)
+				utf8 = utf8.Slice(1);
+				position += 1;
+			}
+			else if ((utf8[0] & 0b_1110_0000) == 0b_1100_0000)
 			{
-				var toBeEscaped = source.IndexOfAny(this._toBeEscaped.Span);
-				if (toBeEscaped < 0)
+				if (utf8.Length < 2)
 				{
-					// Copy entire source to sink, and then advance buffer.
-					source.CopyTo(sink);
-					sourceUsed += source.Length;
-					sinkUsed += source.Length;
-					continue;
+					JsonThrow.TooShortUtf8();
 				}
 
-				if (toBeEscaped > 0)
+				// 2 bytes, 5 + 6 bits
+				var bits1 = utf8[0] & 0b_0001_1111;
+				var bits2 = utf8[1] & 0b_0011_1111;
+
+				if ((bits1 & 0b_1_1110) == 0
+					|| (utf8[1] & 0b_1100_0000) != 0b_1000_0000)
 				{
-					// Copy source data which have not to be escaped to sink, and then advance buffer.
-					source.Slice(0, toBeEscaped).CopyTo(sink);
-					sink = sink.Slice(toBeEscaped);
-					sourceUsed += toBeEscaped;
-					sinkUsed += toBeEscaped;
-					source = source.Slice(toBeEscaped);
+					JsonThrow.MalformedUtf8(utf8, position);
 				}
 
-#warning TODO: OPTIONS
-				var escapeSequence = GetEscapeSequence(source[0], newLineAllowed: false);
-				switch (escapeSequence.Length)
+				ushort codePoint = (ushort)((bits1 << 6) | (bits2 << 6));
+
+				if (codePoint < 0xA0 // Control chars must be escaped
+					|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
 				{
-					case 1:
-					{
-						// Does not escape because of the option.
-						sink[0] = source[0];
-						sink = sink.Slice(1);
-						sinkUsed++;
-						break;
-					}
-					case 0:
-					{
-						// \uXXXX escape
-						if (sink.Length < 6)
-						{
-							// Return to expecte realloc.
-							return source.Length + 6;
-						}
-
-						JsonEscapeSequence.Unicode.Span.CopyTo(sink);
-						sink = sink.Slice(2); // \u
-						Utf8Formatter.TryFormat(source[0], sink, out _, JsonEscapeSequence.UnicodeFormat);
-						sink = sink.Slice(4); // xxxx
-						sinkUsed += 6;
-						break;
-					}
-					default:
-					{
-						// Use returned escape sequence
-
-						if (sink.Length < escapeSequence.Length)
-						{
-							// Return to expecte realloc.
-							return source.Length + escapeSequence.Length;
-						}
-
-						escapeSequence.Span.CopyTo(sink);
-						sink = sink.Slice(escapeSequence.Length);
-						sinkUsed += escapeSequence.Length;
-						break;
-					}
-				} // switch
+					EscapeCodePoint(codePoint, buffer);
+				}
+				else
+				{
+					buffer.Write(utf8.Slice(0, 1));
+				}
+
+				utf8 = utf8.Slice(2);
+				position += 2;
+			}
+			else if ((utf8[0] & 0b_1111_0000) == 0b_1110_0000)
+			{
+				if (utf8.Length < 3)
+				{
+					JsonThrow.TooShortUtf8();
+				}
+
+				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
+					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000)
+				{
+					JsonThrow.MalformedUtf8(utf8, position);
+				}
+
+				// 3 bytes, 4 + 6 + 6 bits
+				var bits1 = utf8[0] & 0b_0000_1111;
+				var bits2 = utf8[1] & 0b_0011_1111;
+				var bits3 = utf8[2] & 0b_0011_1111;
+
+				ushort codePoint = (ushort)((bits1 << 12) | (bits2 << 6) | bits3);
+
+				if ((codePoint & 0b_1111_100000_000000) == 0)
+				{
+					JsonThrow.MalformedUtf8(utf8, position);
+				}
+
+				if (!Rune.IsValid(codePoint))
+				{
+					JsonThrow.SurrogateCharInUtf8(position, codePoint);
+				}
+
+				if (codePoint >= 0xFFFE // U+FFFE and U+FFFF are Reserved
+					|| (this._options.EscapesPrivateUseCharactors && codePoint >= 0xE000 && codePoint <= 0xF8FF) // Privte Use
+					|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
+				{
+					EscapeCodePoint(codePoint, buffer);
+				}
+				else
+				{
+					buffer.Write(utf8.Slice(0, 1));
+				}
+
+				utf8 = utf8.Slice(3);
+				position += 3;
+			}
+			else if ((utf8[0] & 0b_1111_1000) == 0b_1111_0000)
+			{
+				if (utf8.Length < 4)
+				{
+					JsonThrow.TooShortUtf8();
+				}
+
+				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
+					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000
+					|| (utf8[3] & 0b_1100_0000) != 0b_1000_0000)
+				{
+					JsonThrow.MalformedUtf8(utf8, position);
+				}
+
+				// 4 bytes, 3 + 6 + 6 + 6 bits
+				var bits1 = (utf8[0] & 0b_0000_0111) << 18;
+				var bits2 = (utf8[1] & 0b_0011_1111) << 12;
+				var bits3 = (utf8[2] & 0b_0011_1111) << 6;
+				var bits4 = (utf8[3] & 0b_0011_1111);
 
-				sourceUsed++;
-				source = source.Slice(1);
-			} // while (!source.IsEmpty)
+				int codePoint = ((bits1 << 18) | (bits2 << 12) | (bits1 << 6) | bits4);
+
+				if ((codePoint & 0b_111_110000_000000_000000) == 0)
+				{
+					JsonThrow.MalformedUtf8(utf8, position);
+				}
+
+				if ((this._options.EscapesPrivateUseCharactors && codePoint >= 0xF0000) // Private use
+					|| this._escapeTargetChars4Byte.Span.Contains(codePoint))
+				{
+					EscapeCodePoint(codePoint, buffer);
+				}
+				else
+				{
+					buffer.Write(utf8.Slice(0, 1));
+				}
+
+				utf8 = utf8.Slice(4);
+				position += 4;
+			}
+			else
+			{
+				JsonThrow.MalformedUtf8(utf8, position);
+			}
+		}
 
-			return 0;
+		private static void EscapeCodePoint(int codePoint, IBufferWriter<byte> buffer)
+		{
+			buffer.Write(JsonEscapeSequence.Unicode);
+			Span<byte> numbers = stackalloc byte[4];
+			Utf8Formatter.TryFormat(codePoint, numbers, out _, JsonEscapeSequence.UnicodeFormat);
+			buffer.Write(numbers);
 		}
 
-		public override void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer)
+		public override void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
+			buffer = EnsureNotNull(buffer);
+
 			// Start quot
-			buffer.Write(JsonTokens.Quatation.Span);
+			buffer.Write(JsonTokens.Quatation);
 
 			var source = new SequenceReader<byte>(encodedValue);
 
 			while (!source.UnreadSpan.IsEmpty)
 			{
 				var length = source.UnreadSpan.Length;
-				this.EncodeStringBody(source.UnreadSpan, buffer);
+				this.EncodeStringBody(source.UnreadSpan, source.Consumed, buffer);
 				source.Advance(length);
 			}
 
 			// End quot
-			buffer.Write(JsonTokens.Quatation.Span);
+			buffer.Write(JsonTokens.Quatation);
 		}
 
-		public override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		public override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
+			buffer = EnsureNotNull(buffer);
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+
 			if (value.Length < 256)
 			{
 				// Fast-path with stackalloc
@@ -525,12 +562,12 @@ public override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte>
 				// Slow-path
 
 				// Start quot
-				buffer.Write(JsonTokens.Quatation.Span);
+				buffer.Write(JsonTokens.Quatation);
 
 				var encoder = encoding.GetEncoder();
 				var source = value;
 
-				var encodingBuffer = this.ByteArrayPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
+				var encodingBuffer = base.Options.ByteBufferPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
 				try
 				{
 					Span<byte> encodingSpan = encodingBuffer;
@@ -539,22 +576,25 @@ public override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte>
 						var length = source.Length;
 						encoder.Convert(source, encodingSpan, flush: source.Length <= encodingSpan.Length, out var charsUsed, out var bytesUsed, out _);
 
-						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), buffer);
+						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), position: 0 /* should not be used because ALWAYS valid UTF-8 */, buffer);
 						source = source.Slice(charsUsed);
 					}
 				}
 				finally
 				{
-					this.ByteArrayPool.Return(encodingBuffer, this.ClearsBufferPool);
+					base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
 				}
 
 				// End quot
-				buffer.Write(JsonTokens.Quatation.Span);
+				buffer.Write(JsonTokens.Quatation);
 			}
 		}
 
-		public override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding encoding)
+		public override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
+			buffer = EnsureNotNull(buffer);
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+
 			if (value.IsSingleSegment)
 			{
 				this.EncodeString(value.FirstSpan, buffer, encoding);
@@ -574,211 +614,102 @@ public override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter
 				// Slow-path
 
 				// Start quot
-				buffer.Write(JsonTokens.Quatation.Span);
+				buffer.Write(JsonTokens.Quatation);
 
 				var encoder = encoding.GetEncoder();
 				var source = new SequenceReader<char>(value);
 
-				var encodingBuffer = this.ByteArrayPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
+				var encodingBuffer = base.Options.ByteBufferPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
 				try
 				{
 					Span<byte> encodingSpan = encodingBuffer;
 					while (!source.UnreadSpan.IsEmpty)
 					{
+						cancellationToken.ThrowIfCancellationRequested();
+
 						var length = source.UnreadSpan.Length;
 						encoder.Convert(source.UnreadSpan, encodingSpan, flush: source.Remaining <= encodingSpan.Length, out var charsUsed, out var bytesUsed, out _);
 
-						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), buffer);
+						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), position: 0 /* should not be used because ALWAYS valid UTF-8 */, buffer);
 						source.Advance(charsUsed);
 					}
 				}
 				finally
 				{
-					this.ByteArrayPool.Return(encodingBuffer, this.ClearsBufferPool);
+					base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
 				}
 
 				// End quot
-				buffer.Write(JsonTokens.Quatation.Span);
+				buffer.Write(JsonTokens.Quatation);
 			}
 		}
 
-		protected override async ValueTask<long> EncodeLargeStringCoreAsync(TextReader source, Stream sink, Encoding encoding, Func<Stream> bufferStreamProvider, CancellationToken cancellationToken)
+		public override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
 			// Start quot
-			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
-			long written = JsonTokens.Quatation.Length;
-
-			var maxBytesPerChar = encoding.GetMaxByteCount(1);
-			var encoder = encoding.GetEncoder();
-			var charBufferLength = ByteBufferLength / maxBytesPerChar;
+			buffer.Write(JsonTokens.Quatation);
 
-			var encodingBufferArray = this.ByteArrayPool.Rent(ByteBufferLength);
-			try
+			if (value.Length < this.Options.CancellationSupportThreshold)
 			{
-				var sourceBufferArray = this.CharArrayPool.Rent(charBufferLength);
-				try
-				{
-					var escapingBufferArray = this.ByteArrayPool.Rent(ByteBufferLength);
-					try
-					{
-						Memory<char> sourceBuffer = sourceBufferArray;
-						Memory<byte> encodingBuffer = encodingBufferArray;
-						Memory<byte> escapingBuffer = escapingBufferArray;
-
-						bool completed = false;
-
-						do
-						{
-							var readLength = await source.ReadAsync(sourceBuffer, cancellationToken).ConfigureAwait(false);
-							var shouldFlush = readLength <= sourceBuffer.Length && source.Peek() < 0;
-							var chars = sourceBuffer.Slice(0, readLength);
-							while (!chars.IsEmpty)
-							{
-								encoder.Convert(chars, encodingBuffer, shouldFlush, out var charsUsed, out var bytesUsed, out completed);
-								encodingBuffer = encodingBuffer.Slice(0, bytesUsed);
-
-								while (!encodingBuffer.IsEmpty)
-								{
-									var moreEscapingBufferSize = this.EscapeStringContent(encodingBuffer, escapingBuffer, out var encodingBufferUsed, out var escapingBufferUsed);
-
-									await sink.WriteAsync(escapingBuffer.Slice(0, escapingBufferUsed), cancellationToken).ConfigureAwait(false);
-									written += escapingBufferUsed;
-
-									encodingBuffer = encodingBuffer.Slice(encodingBufferUsed);
-									escapingBuffer = escapingBuffer.Compact(escapingBufferArray, escapingBufferUsed);
-								}
-
-								chars = chars.Slice(charsUsed);
-							}
-						} while (!completed);
-					}
-					finally
-					{
-						this.ByteArrayPool.Return(escapingBufferArray, this.ClearsBufferPool);
-					}
-				}
-				finally
-				{
-					this.CharArrayPool.Return(sourceBufferArray, this.ClearsBufferPool);
-				}
+				// Enough space -- over 138% 
+				var span = buffer.GetSpan((int)(value.Length * 1.38));
+				Base64.EncodeToUtf8(value, span, out var bytesConsumed, out var bytesWritten, isFinalBlock: true);
+				buffer.Advance(bytesWritten);
 			}
-			finally
+			else
 			{
-				this.ByteArrayPool.Return(encodingBufferArray, this.ClearsBufferPool);
+				EncodeBinarySlow(value, buffer, this.Options.CancellationSupportThreshold, cancellationToken);
 			}
 
 			// End quot
-			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
-			written += JsonTokens.Quatation.Length;
-
-			return written;
-		}
-
-		public override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer)
-		{
-			// Start quot
-			buffer.Write(JsonTokens.Quatation.Span);
-
-			// Enough space -- over 138% 
-			var span = buffer.GetSpan((int)(value.Length * 1.38));
-			Base64.EncodeToUtf8(value, span, out var bytesConsumed, out var bytesWritten, isFinalBlock: true);
-			buffer.Advance(bytesWritten);
-
-			// End quot
-			buffer.Write(JsonTokens.Quatation.Span);
+			buffer.Write(JsonTokens.Quatation);
 		}
 
-		public override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer)
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static void EncodeBinarySlow(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, int bufferSize, CancellationToken cancellationToken)
 		{
-			// Start quot
-			buffer.Write(JsonTokens.Quatation.Span);
-
-			var array = this.ByteArrayPool.Rent(ByteBufferLength);
-			try
+			while (true)
 			{
-				var reader = new SequenceReader<byte>(value);
-				Span<byte> sourceBuffer = array;
-
-				while (true)
+				var span = buffer.GetSpan(bufferSize);
+				if (Base64.EncodeToUtf8(value, span, out var bytesConsumed, out var bytesWritten, isFinalBlock: value.IsEmpty) == OperationStatus.Done)
 				{
-					if (!reader.TryCopyTo(sourceBuffer))
-					{
-						while (!reader.End)
-						{
-							reader.UnreadSpan.CopyTo(sourceBuffer);
-							sourceBuffer = sourceBuffer.Slice(0, reader.UnreadSpan.Length);
-							reader.Advance(reader.UnreadSpan.Length);
-						}
-					}
-
-					var span = buffer.GetSpan(sourceBuffer.Length * 2);
-					var status = Base64.EncodeToUtf8(sourceBuffer, span, out var bytesConsumed, out var bytesWritten, reader.End);
-					buffer.Advance(bytesWritten);
-					reader.Advance(bytesConsumed);
-					sourceBuffer = array;
-
-					if (status == OperationStatus.Done && reader.End)
-					{
-						break;
-					}
+					break;
 				}
 
-				// End quot
-				buffer.Write(JsonTokens.Quatation.Span);
-			}
-			finally
-			{
-				this.ByteArrayPool.Return(array, this.ClearsBufferPool);
+				buffer.Advance(bytesWritten);
+				value = value.Slice(bytesConsumed);
+				cancellationToken.ThrowIfCancellationRequested();
 			}
-
-			// End quot
-			buffer.Write(JsonTokens.Quatation.Span);
 		}
 
-		protected override async ValueTask<long> EncodeLargeBinaryCoreAsync(Stream source, Stream sink, Func<Stream> bufferStreamProvider, CancellationToken cancellationToken)
+		public override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
-			static OperationStatus EncodeBase64ToUtf8(ReadOnlyMemory<byte> sourceMemory, Memory<byte> sinkMemory, out int bytesConsumed, out int bytesWritten, bool isFinalBlock)
-				=> Base64.EncodeToUtf8(sourceMemory.Span, sinkMemory.Span, out bytesConsumed, out bytesWritten, isFinalBlock);
-
-			// End quot
-			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
-			long written = JsonTokens.Quatation.Length;
-
-			var sourceBufferArray = this.ByteArrayPool.Rent(ByteBufferLength / 2);
-			try
+			if (value.IsSingleSegment)
 			{
-				var sinkBufferArray = this.ByteArrayPool.Rent(ByteBufferLength);
-				try
-				{
-					Memory<byte> sourceBuffer = sourceBufferArray;
-					Memory<byte> sinkBuffer = sinkBufferArray;
-
-					while (true)
-					{
-						await source.ReadAsync(sourceBuffer, cancellationToken).ConfigureAwait(false);
+				// Fast-path
+				this.EncodeBinary(value.FirstSpan, buffer, cancellationToken);
+				return;
+			}
 
-						var status = EncodeBase64ToUtf8(sourceBuffer, sinkBuffer, out var sourceConsumed, out var sinkWritten, source.Position == source.Length);
+			// Start quot
+			buffer.Write(JsonTokens.Quatation);
 
-						if (status == OperationStatus.Done && source.Position == source.Length)
-						{
-							break;
-						}
-					}
-				}
-				finally
+			var reader = new SequenceReader<byte>(value);
+			while (true)
+			{
+				var span = buffer.GetSpan(this.Options.CancellationSupportThreshold);
+				if (Base64.EncodeToUtf8(reader.UnreadSpan, span, out var bytesConsumed, out var bytesWritten, isFinalBlock: reader.End) == OperationStatus.Done)
 				{
-					this.ByteArrayPool.Return(sinkBufferArray, this.ClearsBufferPool);
+					break;
 				}
-			}
-			finally
-			{
-				this.ByteArrayPool.Return(sourceBufferArray, this.ClearsBufferPool);
+
+				buffer.Advance(bytesWritten);
+				reader.Advance(bytesConsumed);
+				cancellationToken.ThrowIfCancellationRequested();
 			}
 
 			// End quot
-			await sink.WriteAsync(JsonTokens.Quatation, cancellationToken).ConfigureAwait(false);
-			written += JsonTokens.Quatation.Length;
-			return written;
+			buffer.Write(JsonTokens.Quatation);
 		}
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptions.cs b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
new file mode 100644
index 000000000..66014e1cf
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
@@ -0,0 +1,116 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Linq;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines encoder options for <see cref="JsonEncoder"/>.
+	/// </summary>
+	public class JsonEncoderOptions : EncoderOptions
+	{
+		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> ErrorSingleInfinityFormatter =
+			(value, buffer, options) => throw new ArgumentException($"Cannot serialize infinity ({value}) to JSON.", "value");
+
+		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> MinMaxSingleInfinityFormatter =
+			(value, buffer, options) => JsonFormatter.Format(Single.IsPositiveInfinity(value) ? Single.MaxValue : Single.MinValue, buffer, options);
+
+		private static readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> ErrorDoubleInfinityFormatter =
+			(value, buffer, options) => throw new ArgumentException($"Cannot serialize infinity ({value}) to JSON.", "value");
+
+		private static readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> MinMaxDoubleInfinityFormatter =
+			(value, buffer, options) => JsonFormatter.Format(Double.IsPositiveInfinity(value) ? Double.MaxValue : Double.MinValue, buffer, options);
+
+		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> ErrorSingleNaNFormatter =
+			(value, buffer, options) => throw new ArgumentException($"Cannot serialize NaN to JSON.", "value");
+		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> NullSingleNaNFormatter =
+			(value, buffer, options) => JsonFormatter.WriteNull(buffer);
+
+		private static readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> ErrorDoubleNaNFormatter =
+			(value, buffer, options) => throw new ArgumentException($"Cannot serialize NaN to JSON.", "value");
+
+		private static readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> NullDoubleNaNFormatter =
+			(value, buffer, options) => JsonFormatter.WriteNull(buffer);
+
+		private readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions>? _singleInfinityFormatter;
+		private readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions>? _doubleInfinityFormatter;
+		private readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions>? _singleNaNFormatter;
+		private readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions>? _doubleNaNFormatter;
+
+		public ReadOnlyMemory<byte> IndentChars { get; }
+		public ReadOnlyMemory<byte> NewLineChars { get; }
+		public bool IsPrettyPrint { get; }
+		public bool EscapesHorizontalTab { get; }
+		public bool EscapesPrivateUseCharactors { get; }
+		public ReadOnlyMemory<Rune> EscapeTargetChars { get; }
+		internal ReadOnlyMemory<byte> EscapeTargetChars1Byte { get; }
+		internal ReadOnlyMemory<ushort> EscapeTargetChars2Byte { get; }
+		internal ReadOnlyMemory<int> EscapeTargetChars4Byte { get; }
+
+		public JsonEncoderOptions(JsonEncoderOptionsBuilder builder)
+			: base(builder)
+		{
+			this._singleInfinityFormatter =
+				builder.InfinityHandling switch
+				{
+					InfinityHandling.Custom => builder.SingleInfinityFormatter,
+					InfinityHandling.Error => ErrorSingleInfinityFormatter,
+					InfinityHandling.MinMax => MinMaxSingleInfinityFormatter,
+					_ => default,
+				};
+			this._doubleInfinityFormatter =
+				builder.InfinityHandling switch
+				{
+					InfinityHandling.Custom => builder.DoubleInfinityFormatter,
+					InfinityHandling.Error => ErrorDoubleInfinityFormatter,
+					InfinityHandling.MinMax => MinMaxDoubleInfinityFormatter,
+					_ => default,
+				};
+			this._singleNaNFormatter =
+				builder.NaNHandling switch
+				{
+					NaNHandling.Custom => builder.SingleNaNFormatter,
+					NaNHandling.Error => ErrorSingleNaNFormatter,
+					NaNHandling.Null => NullSingleNaNFormatter,
+					_ => default,
+				};
+			this._doubleNaNFormatter =
+				builder.NaNHandling switch
+				{
+					NaNHandling.Custom => builder.DoubleNaNFormatter,
+					NaNHandling.Error => ErrorDoubleNaNFormatter,
+					NaNHandling.Null => NullDoubleNaNFormatter,
+					_ => default,
+				};
+
+			this.IndentChars = builder.IndentChars;
+			this.NewLineChars = builder.NewLineChars;
+			this.IsPrettyPrint = builder.IsPrettyPrint;
+			var escapeTargetChars = builder.AdditionalEscapeTargetChars.ToArray().Concat(JsonCharactor.MustBeEscaped1Byte.Select(b => new Rune(b))).Distinct().OrderBy(r => r).ToArray();
+			this.EscapeTargetChars = escapeTargetChars;
+			this.EscapeTargetChars1Byte = escapeTargetChars.Where(r => r.Value <= Byte.MaxValue).Select(r => (byte)r.Value).ToArray();
+			this.EscapeTargetChars2Byte = escapeTargetChars.Where(r => r.Value > Byte.MaxValue && r.Value <= UInt16.MaxValue).Select(r => (ushort)r.Value).ToArray();
+			this.EscapeTargetChars4Byte = escapeTargetChars.Where(r => r.Value > UInt16.MaxValue).Select(r => r.Value).ToArray();
+			this.EscapesHorizontalTab = builder.EscapesHorizontalTab;
+			this.EscapesPrivateUseCharactors = builder.EscapesPrivateUseCharactors;
+		}
+
+		internal Action<float, IBufferWriter<byte>, JsonEncoderOptions> SingleInfinityFormatter =>
+			this._singleInfinityFormatter ?? MinMaxSingleInfinityFormatter;
+
+		internal Action<float, IBufferWriter<byte>, JsonEncoderOptions> SingleNaNFormatter =>
+			this._singleNaNFormatter ?? NullSingleNaNFormatter;
+
+		internal Action<double, IBufferWriter<byte>, JsonEncoderOptions> DoubleInfinityFormatter =>
+			this._doubleInfinityFormatter ?? MinMaxDoubleInfinityFormatter;
+
+		internal Action<double, IBufferWriter<byte>, JsonEncoderOptions> DoubleNaNFormatter =>
+			this._doubleNaNFormatter ?? NullDoubleNaNFormatter;
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs b/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
new file mode 100644
index 000000000..c68260e1d
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
@@ -0,0 +1,157 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		A builder object to construct immutable <see cref="EncoderOptions"/> object.
+	/// </summary>
+	public class JsonEncoderOptionsBuilder : EncoderOptionsBuilder
+	{
+		private static readonly ReadOnlyMemory<byte> DefaultIndentChars =
+			new byte[] { (byte)' ', (byte)' ' };
+
+		private static readonly ReadOnlyMemory<byte> DefaultNewLineChars =
+			new byte[] { (byte)'\n' };
+
+		private InfinityHandling _infinityHandling = InfinityHandling.Default;
+
+		public InfinityHandling InfinityHandling
+		{
+			get => this._infinityHandling;
+			set => this._infinityHandling = JsonOptionsValidation.EnsureKnownNonCustom(value);
+		}
+
+		private NaNHandling _nanHandling;
+
+		public NaNHandling NaNHandling
+		{
+			get => this._nanHandling;
+			set => this._nanHandling = JsonOptionsValidation.EnsureKnownNonCustom(value);
+		}
+
+		private ReadOnlyMemory<byte> _indentChars = DefaultIndentChars;
+		public ReadOnlyMemory<byte> IndentChars
+		{
+			get => this._indentChars;
+			set
+			{
+				for (var i = 0; i < value.Length; i++)
+				{
+					switch (value.Span[i])
+					{
+						case (byte)' ':
+						case (byte)'\t':
+						case (byte)'\r':
+						case (byte)'\n':
+						{
+							// OK 
+							break;
+						}
+						default:
+						{
+							throw new ArgumentException(
+								$"IndentChars can only contains whitespace (U+0020), horizontal tab (U+0009), carriage return (U+000A), and line feed (U+000D) according to RFC8259, but char at {i} is U+00{value.Span[i]:X2}.",
+								"value"
+							);
+						}
+					}
+				}
+
+				this._indentChars = value;
+			}
+		}
+
+		private ReadOnlyMemory<byte> _newLineChars = DefaultNewLineChars;
+		public ReadOnlyMemory<byte> NewLineChars
+		{
+			get => this._newLineChars;
+			set
+			{
+				for (var i = 0; i < value.Length; i++)
+				{
+					switch (value.Span[i])
+					{
+						case (byte)'\r':
+						case (byte)'\n':
+						{
+							// OK 
+							break;
+						}
+						default:
+						{
+							throw new ArgumentException(
+								$"NewLineChars can only contains carriage return (U+000A), and line feed (U+000D) according to RFC8259, but char at {i} is U+00{value.Span[i]:X2}.",
+								"value"
+							);
+						}
+					}
+				}
+
+				this._newLineChars = value;
+			}
+		}
+
+		public bool IsPrettyPrint { get; set; }
+
+		public ReadOnlyMemory<Rune> AdditionalEscapeTargetChars { get; set; }
+
+		public bool EscapesHorizontalTab { get; set; } = true;
+		public bool EscapesPrivateUseCharactors { get; set; } = true;
+
+		internal Action<float, IBufferWriter<byte>, JsonEncoderOptions>? SingleInfinityFormatter;
+		internal Action<double, IBufferWriter<byte>, JsonEncoderOptions>? DoubleInfinityFormatter;
+		internal Action<float, IBufferWriter<byte>, JsonEncoderOptions>? SingleNaNFormatter;
+		internal Action<double, IBufferWriter<byte>, JsonEncoderOptions>? DoubleNaNFormatter;
+
+		public JsonEncoderOptionsBuilder() { }
+
+		public JsonEncoderOptionsBuilder SetCustomInfinityFormatter(
+			Action<float, IBufferWriter<byte>, JsonEncoderOptions> singleInfinityFormatter,
+			Action<double, IBufferWriter<byte>, JsonEncoderOptions> doubleInfinityFormatter
+		)
+		{
+			this.SingleInfinityFormatter = Ensure.NotNull(singleInfinityFormatter);
+			this.DoubleInfinityFormatter = Ensure.NotNull(doubleInfinityFormatter);
+			this._infinityHandling = InfinityHandling.Custom;
+			return this;
+		}
+
+		public JsonEncoderOptionsBuilder SetCustomNaNFormatter(
+			Action<float, IBufferWriter<byte>, JsonEncoderOptions> singleNaNFormatter,
+			Action<double, IBufferWriter<byte>, JsonEncoderOptions> doubleNaNFormatter
+		)
+		{
+			this.SingleNaNFormatter = Ensure.NotNull(singleNaNFormatter);
+			this.DoubleNaNFormatter = Ensure.NotNull(doubleNaNFormatter);
+			this._nanHandling = NaNHandling.Custom;
+			return this;
+		}
+
+		public JsonEncoderOptionsBuilder WithHtmlCharactorEscaping()
+		{
+			this.AdditionalEscapeTargetChars = JsonCharactor.ShouldBeEscaped;
+			return this;
+		}
+
+		public JsonEncoderOptionsBuilder WithoutHorizontalTabEscaping()
+		{
+			this.EscapesHorizontalTab = false;
+			return this;
+		}
+
+		public JsonEncoderOptionsBuilder WithoutPrivateUseCharsEscaping()
+		{
+			this.EscapesPrivateUseCharactors = false;
+			return this;
+		}
+
+		public JsonEncoderOptions Build() => new JsonEncoderOptions(this);
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonEscapeSequence.cs b/src/MsgPack.Json/Json/JsonEscapeSequence.cs
new file mode 100644
index 000000000..ef8af6318
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonEscapeSequence.cs
@@ -0,0 +1,26 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines known escape sequence int UTF-8 and related structures.
+	/// </summary>
+	internal static class JsonEscapeSequence
+	{
+		public static ReadOnlySpan<byte> Unicode => new[] { (byte)'\\', (byte)'u' };
+		public static ReadOnlySpan<byte> ReverseSolidous => new[] { (byte)'\\', (byte)'\\' };
+		public static ReadOnlySpan<byte> Quatation => new[] { (byte)'\\', (byte)'"' };
+		public static ReadOnlySpan<byte> Tab => new[] { (byte)'\\', (byte)'t' };
+		public static ReadOnlySpan<byte> CarriageReturn => new[] { (byte)'\\', (byte)'r' };
+		public static ReadOnlySpan<byte> LineFeed => new[] { (byte)'\\', (byte)'n' };
+		public static ReadOnlySpan<byte> BackSpace => new[] { (byte)'\\', (byte)'b' };
+		public static ReadOnlySpan<byte> FormFeed => new[] { (byte)'\\', (byte)'f' };
+
+		public static readonly StandardFormat UnicodeFormat = new StandardFormat('X', 4);
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonFormatter.cs b/src/MsgPack.Json/Json/JsonFormatter.cs
new file mode 100644
index 000000000..084622065
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonFormatter.cs
@@ -0,0 +1,36 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Buffers.Text;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines common JSON formatting logic.
+	/// </summary>
+	internal static class JsonFormatter
+	{
+		public static void WriteNull(IBufferWriter<byte> buffer)
+			=> buffer.Write(JsonTokens.Null);
+
+		public static void Format(float value, IBufferWriter<byte> buffer, JsonEncoderOptions options)
+		{
+			var span = buffer.GetSpan(0);
+			while (!Utf8Formatter.TryFormat(value, span, out _))
+			{
+				span = buffer.GetSpan((span.Length + 1) * 2);
+			}
+		}
+
+		public static void Format(double value, IBufferWriter<byte> buffer, JsonEncoderOptions options)
+		{
+			var span = buffer.GetSpan(0);
+			while (!Utf8Formatter.TryFormat(value, span, out _))
+			{
+				span = buffer.GetSpan((span.Length + 1) * 2);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonNumberTokens.cs b/src/MsgPack.Json/Json/JsonNumberTokens.cs
new file mode 100644
index 000000000..e8d9b1c00
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonNumberTokens.cs
@@ -0,0 +1,95 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines JSON number decoding related binary constants which are stored as native BLOB.
+	/// </summary>
+	internal static class JsonNumberTokens
+	{
+		public static readonly byte MinusSign = (byte)'-';
+		public static readonly byte PlusSign = (byte)'+';
+		public static readonly byte SingleByteUnicodeMinusSign = MinusSign;
+		public static readonly byte[][] MultiByteUnicodeMinusSigns =
+			new[]
+			{
+				new byte[] { 0xE2, 0x81, 0xBB }, // U+207B SUPERSCRIPT MINUS SIGN
+				new byte[] { 0xE2, 0x82, 0x8B }, // U+208B SUBSCRIPT MINUS SIGN
+				new byte[] { 0xE2, 0x88, 0x92 }, // U+2212 MINUS SIGN
+				new byte[] { 0xEF, 0xB9, 0xA3 }, // U+FE63 SMALL HYPHEN-MINUS
+				new byte[] { 0xEF, 0xBC, 0x8D }, // U+FF0D FULLWIDTH HYPHEN-MINUS
+			};
+		public static readonly byte SingleByteUnicodePlus = PlusSign;
+		public static readonly byte[][] MultiByteUnicodePlusSigns =
+			new[]
+			{
+				new byte[] { 0xE2, 0x81, 0xBA }, // U+207A SUPERSCRIPT PLUS SIGN
+				new byte[] { 0xE2, 0x82, 0x8A }, // U+208A SUBSCRIPT PLUS SIGN
+				new byte[] { 0xEF, 0xAC, 0xA9 }, // U+FB29 HEBREW LETTER ALTERNATIVE PLUS SIGN
+				new byte[] { 0xEF, 0xB9, 0xA2 }, // U+FE62 SMALL PLUS SIGN
+				new byte[] { 0xEF, 0xBC, 0x8B }, // U+FE0B FULLWIDTH PLUS SIGN
+			};
+		public static ReadOnlySpan<byte> Digits => new byte[] { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 };
+		public static ReadOnlySpan<byte> NonZeroDigits => new byte[] { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 };
+		public static ReadOnlySpan<byte> ExponentialIndicators => new[] { (byte)'E', (byte)'e' };
+		public static ReadOnlySpan<byte> PlusMinusSigns => new[] { (byte)'-', (byte)'+' };
+		public static readonly byte[][] MultiByteUnicodePlusMinusSigns =
+			new[]
+			{
+				new byte[] { 0xE2, 0x81, 0xBB }, // U+207B SUPERSCRIPT MINUS SIGN
+				new byte[] { 0xE2, 0x82, 0x8B }, // U+208B SUBSCRIPT MINUS SIGN
+				new byte[] { 0xE2, 0x88, 0x92 }, // U+2212 MINUS SIGN
+				new byte[] { 0xEF, 0xB9, 0xA3 }, // U+FE63 SMALL HYPHEN-MINUS
+				new byte[] { 0xEF, 0xBC, 0x8D },  // U+FF0D FULLWIDTH HYPHEN-MINUS
+				new byte[] { 0xE2, 0x81, 0xBA }, // U+207A SUPERSCRIPT PLUS SIGN
+				new byte[] { 0xE2, 0x82, 0x8A }, // U+208A SUBSCRIPT PLUS SIGN
+				new byte[] { 0xEF, 0xAC, 0xA9 }, // U+FB29 HEBREW LETTER ALTERNATIVE PLUS SIGN
+				new byte[] { 0xEF, 0xB9, 0xA2 }, // U+FE62 SMALL PLUS SIGN
+				new byte[] { 0xEF, 0xBC, 0x8B }, // U+FE0B FULLWIDTH PLUS SIGN
+			};
+		public static ReadOnlySpan<byte> SingleByteUnicodeExponentialIndicators => ExponentialIndicators;
+		public static readonly byte[][] MultiByteUnicodeExponentialIndicators =
+			new[]
+			{
+				new byte[] { 0xE1, 0xB4, 0xB1 }, // U+1D31 MODIFIER LETTER CAPITAL E
+				new byte[] { 0xE1, 0xB5, 0x89 }, // U+1D49 MODIFIER LETTER SMALL E
+				new byte[] { 0xE2, 0x82, 0x91 }, // U+2091 LATIN SUBSCRIPT SMALL LETTER E
+				new byte[] { 0xE2, 0x84, 0xAF }, // U+212F SCRIPT SMALL E
+				new byte[] { 0xE2, 0x84, 0xB0 }, // U+2130 SCRIPT CAPITAL E
+				new byte[] { 0xE2, 0x85, 0x87 }, // U+2147 DOUBLE-STRUCK ITALIC SMALL E
+				new byte[] { 0xE2, 0x92, 0xBA }, // U+24BA CIRCLED LATIN CAPITAL LETTER E
+				new byte[] { 0xE2, 0x93, 0x94 }, // U+24D4 CIRCLED LATIN SMALL LETTER E
+				new byte[] { 0xEF, 0xBC, 0xA5 }, // U+FF25 FULLWIDTH LATIN CAPITAL LETTER E
+				new byte[] { 0xEF, 0xBD, 0x85 }, // U+FF45 FULLWIDTH LATIN SMALL LETTER E
+				new byte[] { 0xF0, 0x9D, 0x90, 0x84 }, // U+1D404 MATHEMATICAL BOLD CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x90, 0x9E }, // U+1D41E ATHEMATICAL BOLD SMALL E
+				new byte[] { 0xF0, 0x9D, 0x90, 0xB8 }, // U+1D438 MATHEMATICAL ITALIC CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x91, 0x92 }, // U+1D452 MATHEMATICAL ITALIC SMALL E
+				new byte[] { 0xF0, 0x9D, 0x91, 0xAC }, // U+1D46C MATHEMATICAL BOLD ITALIC CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x92, 0x86 }, // U+1D486 MATHEMATICAL BOLD ITALIC SMALL E
+				new byte[] { 0xF0, 0x9D, 0x93, 0x94 }, // U+1D4D4 MATHEMATICAL BOLD SCRIPT CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x93, 0xAE }, // U+1D4EE MATHEMATICAL BOLD SCRIPT SMALL E
+				new byte[] { 0xF0, 0x9D, 0x94, 0x88 }, // U+1D508 MATHEMATICAL FRAKTUR CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x94, 0xA2 }, // U+1D522 MATHEMATICAL FRAKTUR SMALL E
+				new byte[] { 0xF0, 0x9D, 0x94, 0xBC }, // U+1D53C MATHEMATICAL DOUBLE-STRUCK CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x95, 0x96 }, // U+1D556 MATHEMATICAL DOUBLE-STRUCK SMALL E
+				new byte[] { 0xF0, 0x9D, 0x95, 0xB0 }, // U+1D570 MATHEMATICAL BOLD FRAKTUR CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x96, 0x8A }, // U+1D58A MATHEMATICAL BOLD FRAKTUR SMALL E
+				new byte[] { 0xF0, 0x9D, 0x96, 0xA4 }, // U+1D5A4 MATHEMATICAL SANS-SERIF CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x96, 0xBE }, // U+1D5BE MATHEMATICAL SANS-SERIF SMALL E
+				new byte[] { 0xF0, 0x9D, 0x97, 0x98 }, // U+1D5D8 MATHEMATICAL SANS-SERIF BOLD CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x97, 0xB2 }, // U+1D5F2 MATHEMATICAL SANS-SERIF BOLD SMALL E
+				new byte[] { 0xF0, 0x9D, 0x98, 0x8C }, // U+1D60C MATHEMATICAL SANS-SERIF ITALIC CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x98, 0xA6 }, // U+1D626 MATHEMATICAL SANS-SERIF ITALIC SMALL E
+				new byte[] { 0xF0, 0x9D, 0x99, 0x80 }, // U+1D640 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x99, 0x9A }, // U+1D65A MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL E
+				new byte[] { 0xF0, 0x9D, 0x99, 0xB4 }, // U+1D674 MATHEMATICAL MONOSPACE CAPITAL E
+				new byte[] { 0xF0, 0x9D, 0x9A, 0x8E }, // U+1D68E MATHEMATICAL MONOSPACE SMALL E
+				new byte[] { 0xF0, 0x9F, 0x84, 0xB4 }, // U+1F134 SQUARED LATIN CAPITAL LETTER E
+			};
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonOptionsValidation.cs b/src/MsgPack.Json/Json/JsonOptionsValidation.cs
new file mode 100644
index 000000000..a74f29922
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonOptionsValidation.cs
@@ -0,0 +1,61 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines common validation logic for option builders.
+	/// </summary>
+	internal static class JsonOptionsValidation
+	{
+		public static InfinityHandling EnsureKnownNonCustom(InfinityHandling value, [CallerArgumentExpression("value")]string paramName = null!)
+		{
+			switch (value)
+			{
+				case InfinityHandling.Default:
+				case InfinityHandling.Error:
+				case InfinityHandling.MinMax:
+				{
+					break;
+				}
+				case InfinityHandling.Custom:
+				{
+					throw new ArgumentException(paramName, $"Value 'Custom' cannot be set via property setter.");
+				}
+				default:
+				{
+					throw new ArgumentOutOfRangeException(paramName, $"Value '{value:d}' is not known enum value of enum type '{typeof(InfinityHandling)}'");
+				}
+			}
+
+			return value;
+		}
+
+		public static NaNHandling EnsureKnownNonCustom(NaNHandling value, [CallerArgumentExpression("value")]string paramName = null!)
+		{
+			switch (value)
+			{
+				case NaNHandling.Default:
+				case NaNHandling.Error:
+				case NaNHandling.Null:
+				{
+					break;
+				}
+				case NaNHandling.Custom:
+				{
+					throw new ArgumentException(paramName, $"Value 'Custom' cannot be set via property setter.");
+				}
+				default:
+				{
+					throw new ArgumentOutOfRangeException(paramName, $"Value '{value:d}' is not known enum value of enum type '{typeof(NaNHandling)}'");
+				}
+			}
+
+			return value;
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonParseOptions.cs b/src/MsgPack.Json/Json/JsonParseOptions.cs
new file mode 100644
index 000000000..fc7f5f6c1
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonParseOptions.cs
@@ -0,0 +1,95 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines JSON parser options in deserialization.
+	/// </summary>
+	[Flags]
+	public enum JsonParseOptions
+	{
+		/// <summary>
+		///		No options specified. This should be fastest.
+		/// </summary>
+		None = 0,
+
+		/// <summary>
+		///		Allows single line comment which starts with <c>#</c> outside of string value.
+		/// </summary>
+		AllowHashSingleLineComment = 0x1,
+
+		/// <summary>
+		///		Allows single line comment which starts with <c>//</c> outside of string value.
+		/// </summary>
+		AllowDoubleSolidousSingleLineComment = 0x2,
+
+		/// <summary>
+		///		Allows multi line comment which starts with <c>/*</c> and ends with <c>*/</c> outside of string value.
+		/// </summary>
+		AllowMultilineComment = 0x4,
+
+		/// <summary>
+		///		Allows Unicode whitespace chars such as 1/4 spacing and full width space, and treats them as ASCII whitespace.
+		/// </summary>
+		AllowUnicodeWhitespace = 0x10,
+
+		/// <summary>
+		///		Allows all trivial tokens.
+		/// </summary>
+		AllowAllTrivias = 0xFF,
+
+		/// <summary>
+		///		Allows <c>+NaN</c> and <c>-NaN</c> as valid number.
+		/// </summary>
+		AllowNaN = 0x100,
+
+		/// <summary>
+		///		Allows <c>+Infinity</c> and <c>-Infinity</c> as valid number.
+		/// </summary>
+		AllowInfinity = 0x200,
+
+		/// <summary>
+		///		Allows <c>undefined</c> as valid value, and treats it as <c>null</c>.
+		/// </summary>
+		AllowUndefined = 0x1000,
+
+		/// <summary>
+		///		Allows all irregal values which is not valid in RFC 8259 but is valid as ECMA Script literal.
+		/// </summary>
+		AllowIrregalValues = 0xFF00,
+
+		/// <summary>
+		///		Allows <c>=</c> as object key-valid separator as well as <c>:</c>.
+		/// </summary>
+		AllowEqualSignSeparator = 0x10000,
+
+		/// <summary>
+		///		Allows <c>;</c> as collection item delimiter as well as <c>,</c>.
+		/// </summary>
+		AllowSemicolonDelimiter = 0x20000,
+
+		/// <summary>
+		///		Allows extra trailing comma after last collection item.
+		/// </summary>
+		AllowExtraComma = 0x40000,
+
+		/// <summary>
+		///		Allows <c>'</c> for string value quotation instead of <c>"</c>.
+		/// </summary>
+		AllowSingleQuotationString = 0x100000,
+
+		/// <summary>
+		///		Allows all known syntax errors.
+		/// </summary>
+		AllowWellknownSyntaxErrors = 0xFF0000,
+
+		/// <summary>
+		///		Allows all grammer errors.
+		/// </summary>
+		AllowAllErrors = unchecked((int)0xFFFFFFFF)
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonStringTokens.cs b/src/MsgPack.Json/Json/JsonStringTokens.cs
new file mode 100644
index 000000000..89334c75b
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonStringTokens.cs
@@ -0,0 +1,43 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines JSON string decoding related binary constants which are stored as native BLOB.
+	/// </summary>
+	internal static class JsonStringTokens
+	{
+		public static ReadOnlySpan<byte> AnyQuotations => new[] { (byte)'"', (byte)'\'' };
+		public static ReadOnlySpan<byte> DoubleQuotation => AnyQuotations.Slice(0, 1);
+		public static ReadOnlySpan<byte> SingleQuotationDelimiters => new[] { (byte)'\'', (byte)'\\' };
+		public static ReadOnlySpan<byte> DoubleQuotationDelimiters => new[] { (byte)'"', (byte)'\\' };
+		public static readonly byte UnescapedCharactorsOffset = UnescapedCharactors[0];
+		public static ReadOnlySpan<byte> UnescapedCharactors =>
+			new byte[]
+			{
+				(byte)'"', // U+0022 "
+				0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, // U+0023-U+002E
+				(byte)'/', // U+002F /
+				0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, // U+0030-U+003F
+				0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, // U+0040-U+004F
+				0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, // U+0050-U+005B
+				(byte)'\\', // U+005C \
+				0xBD, 0xBE, 0xBF, // U+005D-U+005F
+				0xC0, 0xC1, // U+0060-U+0061
+				(byte)'\b', // U+0062 -> U+0008 Back Space
+				0xC3, 0xC4, 0xC5, // U+0063-U+0065
+				(byte)'\f', // U+0066 -> U+000C Form Feed
+				0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, // UL0067-U+006D
+				(byte)'\n', // U+006E -> U+000A Line Feed
+				0xCF, // U+006F
+				0xD0, 0xD1, // U+0070-U+0071
+				(byte)'\r', // U+0072 -> U+000D Carriage Return  
+				0xD3, // U+0073
+				(byte)'\t', // U+0074 -> U+0009 Tab
+			};
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonThrow.cs b/src/MsgPack.Json/Json/JsonThrow.cs
new file mode 100644
index 000000000..aa6f09536
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonThrow.cs
@@ -0,0 +1,117 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	internal static class JsonThrow
+	{
+		public static void TooShortUtf8()
+			=> throw new FormatException($"Input UTF-8 sequence is invalid. The sequence unexpectedly ends.");
+
+		public static CollectionType CollectionHeaderDecodingIsNotSupported(out long itemsCount, out int requestHint)
+			=> throw new NotSupportedException("JSON does not support collection length.");
+
+		public static long CollectionHeaderDecodingIsNotSupported(out int requestHint)
+			=> throw new NotSupportedException("JSON does not support collection length.");
+
+		public static void DrainIsNotSupported(out int requestHint)
+			=> throw new NotSupportedException("JSON does not support collection length.");
+
+		public static void MalformedUtf8(in ReadOnlySpan<byte> sequence, long position)
+			=> throw new FormatException($"Input UTF-8 has invalid sequence {BitConverter.ToString(sequence.ToArray())} at position {position:#,0}.");
+
+		public static void MalformedUtf8(in ReadOnlySequence<byte> sequence, long position)
+			=> throw new FormatException($"Input UTF-8 has invalid sequence {BitConverter.ToString(sequence.ToArray())} at position {position:#,0}.");
+
+		public static void SurrogateCharInUtf8(long position, int codePoint)
+			=> throw new FormatException($"Input UTF-8 has surrogate charactor U+{codePoint:X4} at position {position:#,0}.");
+
+		public static void IsNotArrayNorObject(in ReadOnlySequence<byte> sequence, long position)
+			=> throw new FormatException($"Char '{Stringify(sequence)}' at position {position:#,0} is not start of array nor object.");
+
+		public static void IsNotArray(long position)
+			=> throw new FormatException($"Char '{{' at position {position:#,0} is not start of array.");
+
+		public static void IsNotObject(long position)
+			=> throw new FormatException($"Char '[' at position {position:#,0} is not start of object.");
+
+		public static void IsNotType(Type type, in ReadOnlySequence<byte> unit, long position)
+			=> throw new FormatException($"Char '{Stringify(unit)}' at position {position:#,0} is not valid for {type} value.");
+
+		public static void TooLongNumber(long numberLength, long maxLength, long position)
+			=> throw new FormatException($"The number at position {position:#,0} has {numberLength:#,0} charactors, but maximum allowed length is {maxLength:#,0}.");
+
+		public static void IsNotStringStart(long position, ReadOnlySpan<byte> validQuotations)
+		{
+			if (validQuotations.Length == 1)
+			{
+				throw new FormatException($"String must starts with '{(char)validQuotations[0]}' (U+00{validQuotations[0]:X2}) at {position:#,0}.");
+			}
+			else
+			{
+				throw new FormatException($"String must starts with one of [{String.Join(", ", validQuotations.ToArray().Select(b => $"'{(char)b}'(U + 00{b:X2})"))}] at {position:#,0}.");
+			}
+		}
+
+		public static void InvalidEscapeSequence(long position, byte escaped)
+			=> throw new FormatException($"Escape sequence '\\{(char)escaped}' at {position:#,0} is not valid.");
+
+		public static void InvalidUnicodeEscapeSequence(long position, Span<byte> chars)
+			=> throw new FormatException($"Escape sequence '\\u{Encoding.UTF8.GetString(chars)}' at {position:#,0} is not valid.");
+
+		public static void OrphanSurrogate(long position, int codePoint)
+			=> throw new FormatException($"Surrogate char U+{codePoint:X4} at {position:#,0} is not valid.");
+
+		public static void InvalidBase64(long position)
+			=> throw new FormatException($"String at {position:#,0} is not valid BASE64 sequence.");
+
+		public static void UnexpectedToken(long position, byte token)
+			=> throw new FormatException($"A token {(token >= 0x80 ? $"0x{token:X2}" : (token < 0x7F && token >= 0x20 ? $"'{(char)token}'" : $"U+00{token:X2}"))} is not expected at {position:#,0}.");
+
+		private static string Stringify(in ReadOnlySequence<byte> unit)
+		{
+			var buffer = new StringBuilder();
+			foreach (var rune in Encoding.UTF8.GetString(unit).EnumerateRunes())
+			{
+				var category = Rune.GetUnicodeCategory(rune);
+				switch (category)
+				{
+					case UnicodeCategory.Control:
+					case UnicodeCategory.Format:
+					case UnicodeCategory.LineSeparator:
+					case UnicodeCategory.ModifierLetter:
+					case UnicodeCategory.ModifierSymbol:
+					case UnicodeCategory.NonSpacingMark:
+					case UnicodeCategory.OtherNotAssigned:
+					case UnicodeCategory.ParagraphSeparator:
+					case UnicodeCategory.SpacingCombiningMark:
+					case UnicodeCategory.Surrogate:
+					{
+						buffer.Append($"<control-charactor>(U+{rune.Value:X4}, {category})");
+						break;
+					}
+					case UnicodeCategory.SpaceSeparator:
+					{
+						buffer.Append($"'{rune}'(U+{rune.Value:X4}, {category})");
+						break;
+					}
+					default:
+					{
+						buffer.Append('\'').Append(rune).Append('\'');
+						break;
+					}
+				}
+			}
+
+			return buffer.ToString();
+		}
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonTokens.cs b/src/MsgPack.Json/Json/JsonTokens.cs
new file mode 100644
index 000000000..0ac1260dd
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonTokens.cs
@@ -0,0 +1,29 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines JSON tokens as UTF-8 byte blob data.
+	/// </summary>
+	internal static class JsonTokens
+	{
+		// Utilizes C# optimization to read data directly from blob metadata without array allocation.
+		public static ReadOnlySpan<byte> Null => new[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
+		public static ReadOnlySpan<byte> True => new[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e' };
+		public static ReadOnlySpan<byte> False => new[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e' };
+		public static ReadOnlySpan<byte> ArrayStart => new[] { (byte)'[' };
+		public static ReadOnlySpan<byte> ArrayEnd => new[] { (byte)']' };
+		public static ReadOnlySpan<byte> MapStart => new[] { (byte)'{' };
+		public static ReadOnlySpan<byte> MapEnd => new[] { (byte)'}' };
+		public static ReadOnlySpan<byte> Whitespace => new[] { (byte)' ' };
+		public static ReadOnlySpan<byte> Comma => new[] { (byte)',' };
+		public static ReadOnlySpan<byte> Colon => new[] { (byte)':' };
+		public static ReadOnlySpan<byte> Quatation => new[] { (byte)'"' };
+
+		public static ReadOnlySpan<byte> Undefined => new[] { (byte)'u', (byte)'n', (byte)'d', (byte)'e', (byte)'f', (byte)'i', (byte)'n', (byte)'e', (byte)'d' };
+	}
+}
diff --git a/src/MsgPack.Json/Json/JsonTriviaTokens.cs b/src/MsgPack.Json/Json/JsonTriviaTokens.cs
new file mode 100644
index 000000000..89a3552f1
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonTriviaTokens.cs
@@ -0,0 +1,48 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines JSON trivials decoding related binary constants which are stored as native BLOB.
+	/// </summary>
+	internal static class JsonTriviaTokens
+	{
+		public static ReadOnlySpan<byte> StandardWhitespaces => new[] { (byte)' ', (byte)'\t', (byte)'\r', (byte)'\n' };
+		public static ReadOnlySpan<byte> NewLine => new[] { (byte)'\r', (byte)'\n' };
+		public static ReadOnlySpan<byte> SingleByteUnicodeWhitespaces =>
+			new[] {
+				(byte)' ', (byte)'\t', (byte)'\r', (byte)'\n',
+				(byte)'\u000B',(byte)'\u000C'
+			};
+		public static readonly byte[][] MultiByteUnicodeWhitespaces =
+			new[]
+			{
+				new byte[] { 0xC2, 0x85 }, // U+0085 NEXT LINE (NEL)
+				new byte[] { 0xC2, 0xA0 }, // U+00A0 NO-BREAK SPACE
+				new byte[] { 0xE1, 0x9A, 0x80 }, // U+1680 OGHAM SPACE MARK
+				new byte[] { 0xE1, 0x9A, 0x80 }, // U+2000 EN QUAD
+				new byte[] { 0xE2, 0x80, 0x81 }, // U+2001 EM QUAD
+				new byte[] { 0xE2, 0x80, 0x82 }, // U+2002 EN SPACE
+				new byte[] { 0xE2, 0x80, 0x83 }, // U+2003 EM SPACE
+				new byte[] { 0xE2, 0x80, 0x84 }, // U+2004 THREE-PER-EM SPACE
+				new byte[] { 0xE2, 0x80, 0x85 }, // U+2005 FOUR-PER-EM SPACE
+				new byte[] { 0xE2, 0x80, 0x86 }, // U+2006 SIX-PER-EM SPACE
+				new byte[] { 0xE2, 0x80, 0x87 }, // U+2007 FIGURE SPACE
+				new byte[] { 0xE2, 0x80, 0x88 }, // U+2008 PUNCTUATION SPACE
+				new byte[] { 0xE2, 0x80, 0x89 }, // U+2009 THIN SPACE
+				new byte[] { 0xE2, 0x80, 0x8A }, // U+200A HAIR SPACE
+				new byte[] { 0xE2, 0x80, 0xA8 }, // U+2028 LINE SEPARATOR
+				new byte[] { 0xE2, 0x80, 0xA9 }, // U+2029 PARAGRAPH SEPARATOR
+				new byte[] { 0xE2, 0x80, 0xAF }, // U+202F NARROW NO-BREAK SPACE
+				new byte[] { 0xE2, 0x81, 0x9F }, // U+205F MEDIUM MATHEMATICAL SPACE
+				new byte[] { 0xEe, 0x80, 0x80 }, // U+3000 IDEOGRAPHIC SPACE
+			};
+		public static ReadOnlySpan<byte> SingleLineCommentStart2 => new byte[] { (byte)'/', (byte)'/' };
+		public static ReadOnlySpan<byte> MultiLineCommentStart => new byte[] { (byte)'/', (byte)'*' };
+		public static ReadOnlySpan<byte> MultiLineCommentEnd => new byte[] { (byte)'*', (byte)'/' };
+	}
+}
diff --git a/src/MsgPack.Json/Json/NaNHandling.cs b/src/MsgPack.Json/Json/NaNHandling.cs
new file mode 100644
index 000000000..fe7e95b66
--- /dev/null
+++ b/src/MsgPack.Json/Json/NaNHandling.cs
@@ -0,0 +1,32 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines <c>NaN</c> handling in JSON serialization to be compliant with RFC 8259.
+	/// </summary>
+	public enum NaNHandling
+	{
+		/// <summary>
+		///		Use system default setting. See <see cref="JsonEncoderOptionsBuilder"/> for current default.
+		/// </summary>
+		Default = 0,
+
+		/// <summary>
+		///		Use <c>null</c> for <c>NaN</c>.
+		/// </summary>
+		Null = 1,
+
+		/// <summary>
+		///		Throws exception conservatively.
+		/// </summary>
+		Error = 2,
+
+		/// <summary>
+		///		Use own custom formatting logic.
+		/// </summary>
+		Custom = 3
+	}
+}
diff --git a/src/MsgPack.Json/Json/SimpleJsonDecoder.cs b/src/MsgPack.Json/Json/SimpleJsonDecoder.cs
new file mode 100644
index 000000000..9fd56f598
--- /dev/null
+++ b/src/MsgPack.Json/Json/SimpleJsonDecoder.cs
@@ -0,0 +1,27 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Simple <see cref="JsonDecoder"/> implementation which is optimized for RFC compliant JSON parsing.
+	/// </summary>
+	internal sealed class SimpleJsonDecoder : JsonDecoder
+	{
+		public SimpleJsonDecoder(JsonDecoderOptions options)
+			: base(options) { }
+
+		protected override void ReadTrivia(in SequenceReader<byte> source, out ReadOnlySequence<byte> trivia)
+		{
+			var offset = source.Consumed;
+			var consumed = source.AdvancePastAny(JsonTriviaTokens.StandardWhitespaces);
+			trivia = source.Sequence.Slice(offset, consumed);
+		}
+
+		protected override bool TryReadNull(in SequenceReader<byte> source)
+			=> source.IsNext(JsonTokens.Null, advancePast: true);
+	}
+}
diff --git a/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs b/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs
new file mode 100644
index 000000000..649d095ae
--- /dev/null
+++ b/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs
@@ -0,0 +1,141 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		<see cref="IBufferWriter{T}"/> wrapping <see cref="StringBuilder"/>.
+	/// </summary>
+	/// <remarks>
+	///		<see cref="Dispose"/> method returns internal char buffer to the pool, so it is important to ensure calling it.
+	/// </remarks>
+	internal sealed class StringBuilderBufferWriter : IBufferWriter<char>, IDisposable
+	{
+		private readonly ArrayPool<char> _bufferPool;
+		private readonly bool _clearsArray;
+		private readonly StringBuilder _stringBuilder;
+		private char[] _buffer;
+		private int _currentOffset;
+
+		private int CurrentBufferSize => this._buffer.Length - this._currentOffset;
+
+		public StringBuilderBufferWriter(StringBuilder stringBuilder, JsonDecoderOptions options)
+		{
+			this._stringBuilder = stringBuilder;
+			this._bufferPool = options.CharBufferPool;
+			this._clearsArray = options.ClearsBuffer;
+			this._buffer = this._bufferPool.Rent(options.MaxCharBufferLength);
+		}
+
+		public void Dispose()
+		{
+			var array = Interlocked.Exchange(ref this._buffer, null!);
+			if (array != null)
+			{
+				this._bufferPool.Return(array, this._clearsArray);
+			}
+		}
+
+		public override string ToString()
+		{
+			this.Flush(this._currentOffset);
+			return this._stringBuilder.ToString();
+		}
+
+		private unsafe void Flush(int length)
+		{
+			Debug.Assert(length <= this._buffer.Length, $"length ({length}) <= this._buffer.Length ({this._buffer.Length})");
+			Debug.Assert(length <= this._currentOffset, $"length ({length}) <= this._currentOffset ({this._currentOffset})");
+
+			if (length == 0)
+			{
+				return;
+			}
+
+			this._stringBuilder.Append(this._buffer, 0, length);
+			if (this._currentOffset > length)
+			{
+				// Compact
+				fixed (char* source = this._buffer)
+				fixed (char* destination = this._buffer)
+				{
+					Buffer.MemoryCopy(source + length, destination, this._buffer.Length, this._currentOffset - length);
+				}
+			}
+
+			this._currentOffset = 0;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void Advance(int count)
+		{
+			if (this.CurrentBufferSize > count)
+			{
+				// Just advance offset.
+				this._currentOffset += count;
+				return;
+			}
+
+			this.AdvanceToNewBuffer(count);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private void AdvanceToNewBuffer(int count)
+		{
+			// We must prepare new buffer.
+			var remainingCount = count - this._currentOffset;
+			this.Flush(this._currentOffset);
+			if (remainingCount <= 0)
+			{
+				return;
+			}
+
+			// Fill StringBuilder with zero.
+			this._stringBuilder.Append('\0', remainingCount);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Memory<char> GetMemory(int sizeHint = 0)
+		{
+			if (sizeHint <= this.CurrentBufferSize)
+			{
+				return this._buffer.AsMemory(this._currentOffset);
+			}
+
+			return this.GetMemorySlow(sizeHint);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private Memory<char> GetMemorySlow(int sizeHint)
+		{
+			this.Flush(this._currentOffset);
+			Debug.Assert(this._currentOffset == 0, "this._currentOffset == 0");
+			if (sizeHint <= this._buffer.Length)
+			{
+				return this._buffer.AsMemory();
+			}
+
+			// sizeHint is too large. So realloc buffer.
+			this._bufferPool.Return(this._buffer, this._clearsArray);
+			this._buffer = this._bufferPool.Rent(sizeHint);
+			return this._buffer.AsMemory();
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public Span<char> GetSpan(int sizeHint = 0)
+			=> this.GetMemory(sizeHint).Span;
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void AppendUtf16CodePoint(int utf16CodePoint)
+			=> this.GetSpan(1)[0] = (char)utf16CodePoint;
+	}
+}
diff --git a/src/MsgPack.Json/Json/Unicode.cs b/src/MsgPack.Json/Json/Unicode.cs
new file mode 100644
index 000000000..281448db7
--- /dev/null
+++ b/src/MsgPack.Json/Json/Unicode.cs
@@ -0,0 +1,18 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Json
+{
+	/// <summary>
+	///		Defines Unicode related utilities.
+	/// </summary>
+	internal static class Unicode
+	{
+		public static bool IsLowSurrogate(int cp)
+			=> cp >= 0xDC00u && cp <= 0xDFFFu;
+
+		public static bool IsHighSurrogate(int cp)
+			=> cp >= 0xD800u && cp <= 0xDBFFu;
+	}
+}
diff --git a/src/MsgPack.Json/MsgPack.Json.csproj b/src/MsgPack.Json/MsgPack.Json.csproj
index 214660b44..d3a1baa67 100644
--- a/src/MsgPack.Json/MsgPack.Json.csproj
+++ b/src/MsgPack.Json/MsgPack.Json.csproj
@@ -18,4 +18,32 @@
     <Folder Include="System.Text/" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="Json\JsonDecoder.Nullables.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>JsonDecoder.Nullables.cs</LastGenOutput>
+    </None>
+    <None Update="Json\JsonDecoder.Numbers.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>JsonDecoder.Numbers.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Json\JsonDecoder.Nullables.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>JsonDecoder.Nullables.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Json\JsonDecoder.Numbers.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>JsonDecoder.Numbers.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
 </Project>

From cb2b4c3482e30b87e936666b31fa6443079b4502 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 14 Jun 2020 23:33:13 +0900
Subject: [PATCH 19/82] Add devdoc for JSON deserialization

---
 ...onCollectionStatemachine.drawio.svg.drawio | 414 ++++++++++++++++++
 1 file changed, 414 insertions(+)
 create mode 100644 doc/dev/JsonCollectionStatemachine.drawio.svg.drawio

diff --git a/doc/dev/JsonCollectionStatemachine.drawio.svg.drawio b/doc/dev/JsonCollectionStatemachine.drawio.svg.drawio
new file mode 100644
index 000000000..484b7d2a2
--- /dev/null
+++ b/doc/dev/JsonCollectionStatemachine.drawio.svg.drawio
@@ -0,0 +1,414 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" 
+    xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="601px" height="812px" viewBox="-0.5 -0.5 601 812" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2020-06-14T10:48:24.370Z&quot; agent=&quot;5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36&quot; etag=&quot;96j_r8dRb_L1DT7qnW7j&quot; version=&quot;13.2.4&quot; type=&quot;device&quot;&gt;&lt;diagram name=&quot;Page-1&quot; id=&quot;58cdce13-f638-feb5-8d6f-7d28b1aa9fa0&quot;&gt;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&lt;/diagram&gt;&lt;/mxfile&gt;" style="background-color: rgb(255, 255, 255);">
+    <defs/>
+    <g>
+        <ellipse cx="96" cy="55" rx="11" ry="11" fill="#000000" stroke="#ff0000" transform="rotate(90,96,55)" pointer-events="all"/>
+        <path d="M 111 55 L 247.76 55" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="stroke"/>
+        <path d="M 239.88 59.5 L 248.88 55 L 239.88 50.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="all"/>
+        <path d="M 400 210 L 400 290 Q 400 300 390 300 L 157.24 300" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="stroke"/>
+        <path d="M 165.12 295.5 L 156.12 300 L 165.12 304.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="all"/>
+        <rect x="141" y="30" width="80" height="20" fill="none" stroke="none" pointer-events="all"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 40px; margin-left: 142px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">match /\s*\[/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="181" y="44" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*\[/</text>
+            </switch>
+        </g>
+        <rect x="35" y="270" width="120" height="60" rx="14.4" ry="14.4" fill="#ffffc0" stroke="#ff0000" pointer-events="all"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 300px; margin-left: 36px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Invalid</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="95" y="304" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle">Invalid</text>
+            </switch>
+        </g>
+        <path d="M 96 70 L 96 160 Q 96 170 95.5 170 L 95.25 170 Q 95 170 95 180 L 95 267.76" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="stroke"/>
+        <path d="M 90.5 259.88 L 95 268.88 L 99.5 259.88" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="all"/>
+        <rect x="100" y="210" width="40" height="20" fill="none" stroke="none" pointer-events="all"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 220px; margin-left: 101px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">else</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="120" y="224" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">else</text>
+            </switch>
+        </g>
+        <rect x="250" y="25" width="120" height="60" rx="14.4" ry="14.4" fill="#ffffc0" stroke="#ff0000" pointer-events="all"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 55px; margin-left: 251px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
+                                <i>MaybeItem</i>
+                            </div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="310" y="59" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle">MaybeItem</text>
+            </switch>
+        </g>
+        <path d="M 480 153 L 480 140.35 Q 480 130 469.65 130 L 330.35 130 Q 320 130 320 140.35 L 320 153" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
+        <path d="M 320 153 L 320 199.65 Q 320 210 330.35 210 L 469.65 210 Q 480 210 480 199.65 L 480 153" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 320 153 L 480 153" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 158px; height: 1px; padding-top: 142px; margin-left: 321px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; font-weight: bold; white-space: normal; word-wrap: normal; ">Item</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="400" y="145" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle" font-weight="bold">Item</text>
+            </switch>
+        </g>
+        <ellipse cx="455" cy="181" rx="11" ry="11" fill="#000000" stroke="#ff0000" pointer-events="none"/>
+        <ellipse cx="455" cy="181" rx="15" ry="15" fill="none" stroke="#ff0000" pointer-events="none"/>
+        <path d="M 360 181 L 390.33 181 Q 400.33 181 410.33 181 L 437.76 181" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 429.88 185.5 L 438.88 181 L 429.88 176.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <ellipse cx="345" cy="181" rx="11" ry="11" fill="#000000" stroke="#ff0000" transform="rotate(90,345,181)" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 161px; margin-left: 361px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">(external)</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="400" y="165" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">(external)</text>
+            </switch>
+        </g>
+        <path d="M 0 0 L 60 0 L 60 15 L 50 30 L 0 30 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 60 0 L 600 0 L 600 360 L 0 360 L 0 30" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 15px; margin-left: 1px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">Array</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="30" y="19" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle">Array</text>
+            </switch>
+        </g>
+        <path d="M 360 210 L 360 250 Q 360 260 350 260 L 320 260 Q 310 260 310 250 L 310 87.24" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 314.5 95.12 L 310 86.12 L 305.5 95.12" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 240px; margin-left: 231px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*,/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="270" y="244" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*,/</text>
+            </switch>
+        </g>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 285px; margin-left: 341px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">else</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="360" y="289" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">else</text>
+            </switch>
+        </g>
+        <path d="M 370 70 L 500 70 Q 510 70 510 80 L 510 170 Q 510 180 500 180 L 482.24 180" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 490.12 175.5 L 481.12 180 L 490.12 184.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 60px; margin-left: 442px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">else</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="461" y="64" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">else</text>
+            </switch>
+        </g>
+        <ellipse cx="558" cy="300" rx="11" ry="11" fill="#000000" stroke="#ff0000" pointer-events="none"/>
+        <ellipse cx="558" cy="300" rx="15" ry="15" fill="none" stroke="#ff0000" pointer-events="none"/>
+        <path d="M 370 40 L 548 40 Q 558 40 558 50 L 558 282.76" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 553.5 274.88 L 558 283.88 L 562.5 274.88" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 30px; margin-left: 431px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*]/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="470" y="34" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*]/</text>
+            </switch>
+        </g>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 285px; margin-left: 451px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*]/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="490" y="289" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*]/</text>
+            </switch>
+        </g>
+        <path d="M 440 210 L 440 290 Q 440 300 450 300 L 540.76 300" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 532.88 304.5 L 541.88 300 L 532.88 295.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 0 380 L 60 380 L 60 395 L 50 410 L 0 410 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 60 380 L 600 380 L 600 810 L 0 810 L 0 410" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 395px; margin-left: 1px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">
+                                <b>Object</b>
+                            </div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="30" y="399" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle">Object</text>
+            </switch>
+        </g>
+        <ellipse cx="86" cy="425" rx="11" ry="11" fill="#000000" stroke="#ff0000" transform="rotate(90,86,425)" pointer-events="none"/>
+        <path d="M 101 425 L 212.76 425" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 204.88 429.5 L 213.88 425 L 204.88 420.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 401 700 L 401 750 Q 401 760 391 760 L 148.24 760" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 156.12 755.5 L 147.12 760 L 156.12 764.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 410px; margin-left: 107px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*\[/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="146" y="414" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*\[/</text>
+            </switch>
+        </g>
+        <rect x="26" y="730" width="120" height="60" rx="14.4" ry="14.4" fill="#ffffc0" stroke="#ff0000" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 760px; margin-left: 27px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">Invalid</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="86" y="764" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle">Invalid</text>
+            </switch>
+        </g>
+        <path d="M 86 440 L 86 727.76" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 81.5 719.88 L 86 728.88 L 90.5 719.88" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 590px; margin-left: 91px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">else</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="110" y="594" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">else</text>
+            </switch>
+        </g>
+        <rect x="215" y="395" width="120" height="60" rx="14.4" ry="14.4" fill="#ffffc0" stroke="#ff0000" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 425px; margin-left: 216px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">
+                                <i>MaybeKey</i>
+                            </div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="275" y="429" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle">MaybeKey</text>
+            </switch>
+        </g>
+        <path d="M 480 523 L 480 510.35 Q 480 500 469.65 500 L 330.35 500 Q 320 500 320 510.35 L 320 523" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 320 523 L 320 569.65 Q 320 580 330.35 580 L 469.65 580 Q 480 580 480 569.65 L 480 523" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 320 523 L 480 523" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 158px; height: 1px; padding-top: 512px; margin-left: 321px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; font-weight: bold; white-space: normal; word-wrap: normal; ">Key</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="400" y="515" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle" font-weight="bold">Key</text>
+            </switch>
+        </g>
+        <ellipse cx="455" cy="551" rx="11" ry="11" fill="#000000" stroke="#ff0000" pointer-events="none"/>
+        <ellipse cx="455" cy="551" rx="15" ry="15" fill="none" stroke="#ff0000" pointer-events="none"/>
+        <path d="M 360 551 L 390.33 551 Q 400.33 551 410.33 551 L 437.76 551" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 429.88 555.5 L 438.88 551 L 429.88 546.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <ellipse cx="345" cy="551" rx="11" ry="11" fill="#000000" stroke="#ff0000" transform="rotate(90,345,551)" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 540px; margin-left: 361px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">(external)</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="400" y="544" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">(external)</text>
+            </switch>
+        </g>
+        <path d="M 361 700 L 361 710 Q 361 720 351 720 L 285 720 Q 275 720 275 710 L 275 457.24" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 279.5 465.12 L 275 456.12 L 270.5 465.12" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 710px; margin-left: 194px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*,/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="233" y="714" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*,/</text>
+            </switch>
+        </g>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 750px; margin-left: 344px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">else</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="363" y="754" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">else</text>
+            </switch>
+        </g>
+        <path d="M 335 440 L 390 440 Q 400 440 400 450 L 400 497.76" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 395.5 489.88 L 400 498.88 L 404.5 489.88" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 430px; margin-left: 407px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">else</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="426" y="434" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">else</text>
+            </switch>
+        </g>
+        <ellipse cx="558" cy="760" rx="11" ry="11" fill="#000000" stroke="#ff0000" pointer-events="none"/>
+        <ellipse cx="558" cy="760" rx="15" ry="15" fill="none" stroke="#ff0000" pointer-events="none"/>
+        <path d="M 335 410 L 548 410 Q 558 410 558 420 L 558 742.76" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 553.5 734.88 L 558 743.88 L 562.5 734.88" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 400px; margin-left: 396px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*}/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="435" y="404" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*}/</text>
+            </switch>
+        </g>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 740px; margin-left: 451px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /\s*]/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="490" y="744" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /\s*]/</text>
+            </switch>
+        </g>
+        <path d="M 441 700 L 441 750 Q 441 760 451 760 L 540.76 760" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 532.88 764.5 L 541.88 760 L 532.88 755.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 481 643 L 481 630.35 Q 481 620 470.65 620 L 331.35 620 Q 321 620 321 630.35 L 321 643" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 321 643 L 321 689.65 Q 321 700 331.35 700 L 470.65 700 Q 481 700 481 689.65 L 481 643" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 321 643 L 481 643" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 158px; height: 1px; padding-top: 631px; margin-left: 322px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Verdana; color: #000000; line-height: 1.2; pointer-events: none; font-weight: bold; white-space: normal; word-wrap: normal; ">Value</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="401" y="635" fill="#000000" font-family="Verdana" font-size="12px" text-anchor="middle" font-weight="bold">Value</text>
+            </switch>
+        </g>
+        <ellipse cx="456" cy="671" rx="11" ry="11" fill="#000000" stroke="#ff0000" pointer-events="none"/>
+        <ellipse cx="456" cy="671" rx="15" ry="15" fill="none" stroke="#ff0000" pointer-events="none"/>
+        <path d="M 361 671 L 391.17 671 Q 401.17 671 411.17 671 L 438.76 671" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 430.88 675.5 L 439.88 671 L 430.88 666.5" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <ellipse cx="346" cy="671" rx="11" ry="11" fill="#000000" stroke="#ff0000" transform="rotate(90,346,671)" pointer-events="none"/>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 660px; margin-left: 362px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">(external)</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="401" y="664" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">(external)</text>
+            </switch>
+        </g>
+        <g transform="translate(-0.5 -0.5)">
+            <switch>
+                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
+                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 600px; margin-left: 402px;">
+                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
+                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: none; white-space: normal; word-wrap: normal; ">match /[:=]/</div>
+                        </div>
+                    </div>
+                </foreignObject>
+                <text x="441" y="604" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">match /[:=]/</text>
+            </switch>
+        </g>
+        <path d="M 400 580 L 400 617.76" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+        <path d="M 395.5 609.88 L 400 618.88 L 404.5 609.88" fill="none" stroke="#ff0000" stroke-miterlimit="10" pointer-events="none"/>
+    </g>
+    <switch>
+        <g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/>
+        <a transform="translate(0,-5)" xlink:href="https://desk.draw.io/support/solutions/articles/16000042487" target="_blank">
+            <text text-anchor="middle" font-size="10px" x="50%" y="100%">Viewer does not support full SVG 1.1</text>
+        </a>
+    </switch>
+</svg>
\ No newline at end of file

From c70399e1dd3b83d265a45658727e05e37d61932f Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 15 Jun 2020 21:32:31 +0900
Subject: [PATCH 20/82] Add MessagePackEncoderOptions/MessagePackDecoderOptions
 Default property

---
 src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs | 2 ++
 src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs | 4 +++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs b/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
index b4415c2a4..9472d0358 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
@@ -6,6 +6,8 @@ namespace MsgPack.Internal
 {
 	public sealed class MessagePackDecoderOptions : DecoderOptions
 	{
+		public static MessagePackDecoderOptions Default { get; } = new MessagePackDecoderOptionsBuilder().Build();
+
 		internal MessagePackDecoderOptions(MessagePackDecoderOptionsBuilder builder)
 			: base(builder) { }
 	}
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs b/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
index ad3efa2cf..dfc160c3b 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -6,6 +6,8 @@ namespace MsgPack.Internal
 {
 	public sealed class MessagePackEncoderOptions : EncoderOptions
 	{
+		public static MessagePackEncoderOptions Default { get; } = new MessagePackEncoderOptionsBuilder().Build();
+
 		public MessagePackEncoderOptions(MessagePackEncoderOptionsBuilder builder) : base(builder) { }
 	}
 }

From 0e9a7f45187a501b14b4b450b3ae1302915b75a3 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 15 Jun 2020 21:32:46 +0900
Subject: [PATCH 21/82] WIP: initial benchmark

---
 .../Internal/StreamBufferWriter.cs            |   1 +
 .../Internal/StreamReadOnlyMemoryProvider.cs  |   1 +
 src/MsgPack.Core/_SampleObject.cs             | 107 +++++++++++++++++-
 3 files changed, 106 insertions(+), 3 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
index e320035ad..975db06c4 100644
--- a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
+++ b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
@@ -9,6 +9,7 @@
 
 namespace MsgPack.Internal
 {
+#warning TODO: Pubternal or CodeGen
 	internal sealed class StreamBufferWriter : IBufferWriter<byte>, IAsyncDisposable
 	{
 		private readonly Stream _underlying;
diff --git a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
index c09f44bc8..c67c81e08 100644
--- a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
+++ b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
@@ -9,6 +9,7 @@
 
 namespace MsgPack.Internal
 {
+#warning TODO: PubTernal or CodeGen
 	internal sealed class StreamReadOnlyMemoryProvider
 	{
 		private readonly Stream _stream;
diff --git a/src/MsgPack.Core/_SampleObject.cs b/src/MsgPack.Core/_SampleObject.cs
index 9641a7143..ec77520f9 100644
--- a/src/MsgPack.Core/_SampleObject.cs
+++ b/src/MsgPack.Core/_SampleObject.cs
@@ -8,11 +8,12 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading.Tasks;
+using MsgPack.Internal;
 using MsgPack.Serialization.Internal;
 
-namespace MsgPack.Internal
+namespace MsgPack.Samples
 {
-	internal sealed class SampleObject
+	public class SampleObject
 	{
 		public int Age { get; set; }
 		public string Name { get; set; } = null!;
@@ -41,7 +42,7 @@ internal sealed class SampleObject
 	/// <summary>
 	///		Sample hand made serializer.
 	/// </summary>
-	internal sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleObject, TExtensionType>
+	public sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleObject, TExtensionType>
 	{
 		private bool UseArray { get; set; }
 
@@ -1091,4 +1092,104 @@ public async ValueTask DeserializeToAsync(DeserializationOperationContext<TExten
 			}
 		}
 	}
+
+	public sealed class SampleInt32ArraySerializer<TExtensionType> : IObjectSerializer<int[], TExtensionType>
+	{
+		public void Serialize(in SerializationOperationContext<TExtensionType> context, int[] obj, IBufferWriter<byte> sink)
+		{
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			context.Encoder.EncodeArrayStart(obj.Length, sink, context.CollectionContext);
+			for(var i=0; i <obj.Length;i++)
+			{
+				context.Encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+				context.Encoder.EncodeInt32(obj[i], sink);
+				context.Encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+			}
+			context.Encoder.EncodeArrayEnd(obj.Length, sink, context.CollectionContext);
+		}
+
+		public ValueTask SerializeAsync(SerializationOperationContext<TExtensionType> context, int[] obj, Stream streamSink)
+		{
+			throw new NotImplementedException();
+		}
+
+		public int[] Deserialize(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source)
+		{
+			if (context.Decoder.FormatFeatures.CanCountCollectionItems)
+			{
+				var length = context.Decoder.DecodeArrayHeader(source);
+				var result = new int[length];
+				for (var i = 0; i < result.Length; i++)
+				{
+					result[i] = context.Decoder.DecodeInt32(source);
+				}
+				context.Decoder.Drain(source, context.CollectionContext, 0);
+				return result;
+			}
+			else
+			{
+				var result = new List<int>();
+				var iterator = context.Decoder.DecodeArray(source);
+				while (!iterator.CollectionEnds(source))
+				{
+					result.Add(context.Decoder.DecodeInt32(source));
+				}
+				iterator.Drain(source);
+				return result.ToArray();
+			}
+		}
+
+		public ValueTask<int[]> DeserializeAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		{
+			throw new NotImplementedException();
+		}
+
+		public void DeserializeTo(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source, in int[] obj)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ValueTask DeserializeToAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource, int[] obj)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	public sealed class SampleInt32Serializer<TExtensionType> : IObjectSerializer<int, TExtensionType>
+	{
+		public void Serialize(in SerializationOperationContext<TExtensionType> context, int obj, IBufferWriter<byte> sink)
+		{
+			context.Encoder.EncodeInt32(obj, sink);
+		}
+
+		public ValueTask SerializeAsync(SerializationOperationContext<TExtensionType> context, int obj, Stream streamSink)
+		{
+			throw new NotImplementedException();
+		}
+
+		public int Deserialize(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source)
+		{
+			return context.Decoder.DecodeInt32(source);
+		}
+
+		public ValueTask<int> DeserializeAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		{
+			throw new NotImplementedException();
+		}
+
+		public void DeserializeTo(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source, in int obj)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ValueTask DeserializeToAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource, int obj)
+		{
+			throw new NotImplementedException();
+		}
+	}
 }

From 7ae74e547cbb784808dd6584d4cba3baea06940f Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jun 2020 01:09:35 +0900
Subject: [PATCH 22/82] Port benchmark script from MessagePack for C#

---
 test/Benchmark/Benchmark.csproj               |   40 +
 test/Benchmark/LICENSE                        |   39 +
 .../Benchmark/BenchmarkConfig.cs              |  190 +++
 .../Benchmark/ExtensionMethods.cs             |  153 ++
 .../Benchmark/Fixture/BooleanValueFixture.cs  |   19 +
 .../Benchmark/Fixture/ByteValueFixture.cs     |   19 +
 .../Fixture/DateTimeOffsetValueFixture.cs     |   20 +
 .../Benchmark/Fixture/DateTimeValueFixture.cs |   22 +
 .../Benchmark/Fixture/DecimalValueFixture.cs  |   19 +
 .../Benchmark/Fixture/DoubleValueFixture.cs   |   19 +
 .../Benchmark/Fixture/EnumValueFixture.cs     |   26 +
 .../Fixture/ExpressionTreeFixture.cs          |  255 ++++
 .../Benchmark/Fixture/FloatValueFixture.cs    |   19 +
 .../Benchmark/Fixture/GuidValueFixture.cs     |   17 +
 .../Benchmark/Fixture/IValueFixture.cs        |   14 +
 .../Benchmark/Fixture/IntValueFixture.cs      |   19 +
 .../Benchmark/Fixture/LongValueFixture.cs     |   19 +
 .../Fixture/OtherPrimitiveFixtures.cs         |   71 +
 .../Benchmark/Fixture/ShortValueFixture.cs    |   19 +
 .../Benchmark/Fixture/StringValueFixture.cs   |   31 +
 .../Benchmark/IGenericEquality`1.cs           |   12 +
 .../Benchmark/Models/AccessToken.cs           |   44 +
 .../Benchmark/Models/AccountMerge.cs          |   38 +
 .../Benchmark/Models/Answer.cs                |  234 ++++
 .../Benchmark/Models/Badge.cs                 |   75 +
 .../Benchmark/Models/Comment.cs               |  145 ++
 .../Benchmark/Models/Error.cs                 |   37 +
 .../Benchmark/Models/Event.cs                 |   57 +
 .../Benchmark/Models/Feed.cs                  |  693 +++++++++
 .../Benchmark/Models/FlagOption.cs            |   68 +
 .../Benchmark/Models/InboxItem.cs             |   85 ++
 .../Benchmark/Models/Info.cs                  |  274 ++++
 .../Benchmark/Models/NetworkUser.cs           |   78 ++
 .../Benchmark/Models/Notification.cs          |   70 +
 .../Benchmark/Models/Post.cs                  |  114 ++
 .../Benchmark/Models/Privilege.cs             |   37 +
 .../Benchmark/Models/Question.cs              |  361 +++++
 .../Benchmark/Models/QuestionTimeline.cs      |   85 ++
 .../Benchmark/Models/Reputation.cs            |   74 +
 .../Benchmark/Models/ReputationHistory.cs     |   85 ++
 .../Benchmark/Models/Revision.cs              |  110 ++
 .../Benchmark/Models/SearchExcerpt.cs         |  123 ++
 .../Benchmark/Models/ShallowUser.cs           |  112 ++
 .../Benchmark/Models/SuggestedEdit.cs         |   80 ++
 .../MessagePackCsharp/Benchmark/Models/Tag.cs |   64 +
 .../Benchmark/Models/TagScore.cs              |   37 +
 .../Benchmark/Models/TagSynonym.cs            |   48 +
 .../Benchmark/Models/TagWiki.cs               |   60 +
 .../Benchmark/Models/TopTag.cs                |   52 +
 .../Benchmark/Models/User.cs                  |  219 +++
 .../Benchmark/Models/UserTimeline.cs          |   90 ++
 .../Benchmark/Models/WritePermission.cs       |   57 +
 .../Benchmark/SerializerBenchmark.cs          | 1234 +++++++++++++++++
 .../Benchmark/Serializers/BinaryFormatter.cs  |   29 +
 .../Benchmark/Serializers/CerasSerializer.cs  |   21 +
 .../Serializers/DataContractSerializer.cs     |   29 +
 .../Serializers/FsPicklerSerializer.cs        |   31 +
 .../Benchmark/Serializers/HagarSerializer.cs  |   59 +
 .../Serializers/HyperionSerializer.cs         |   31 +
 .../Benchmark/Serializers/JilSerializer.cs    |   21 +
 .../Serializers/JsonNetSerializer.cs          |   39 +
 .../Serializers/MessagePackSerializer.cs      |  123 ++
 .../Serializers/MsgPackCliSerializer.cs       |   20 +
 .../Serializers/ProtobufSerializer.cs         |   29 +
 .../Benchmark/Serializers/SerializerBase.cs   |   14 +
 .../Serializers/SpanJsonSerializer.cs         |   19 +
 .../Serializers/SystemTextJsonSerializer.cs   |   20 +
 .../Serializers/Utf8JsonSerializer.cs         |   19 +
 test/Benchmark/Readme.md                      |   14 +
 69 files changed, 6500 insertions(+)
 create mode 100644 test/Benchmark/Benchmark.csproj
 create mode 100644 test/Benchmark/LICENSE
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/BenchmarkConfig.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/ExtensionMethods.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/BooleanValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ByteValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeOffsetValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DecimalValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DoubleValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/EnumValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ExpressionTreeFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/FloatValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/GuidValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IntValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/LongValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/OtherPrimitiveFixtures.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ShortValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Fixture/StringValueFixture.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/IGenericEquality`1.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/AccessToken.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/AccountMerge.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Answer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Badge.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Comment.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Error.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Event.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Feed.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/FlagOption.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/InboxItem.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Info.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/NetworkUser.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Notification.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Post.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Privilege.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Question.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/QuestionTimeline.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Reputation.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/ReputationHistory.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Revision.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/SearchExcerpt.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/ShallowUser.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/SuggestedEdit.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/Tag.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/TagScore.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/TagSynonym.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/TagWiki.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/TopTag.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/User.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/UserTimeline.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Models/WritePermission.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/SerializerBenchmark.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/BinaryFormatter.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/CerasSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/DataContractSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/FsPicklerSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HagarSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HyperionSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JilSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JsonNetSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MessagePackSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/ProtobufSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SerializerBase.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SpanJsonSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SystemTextJsonSerializer.cs
 create mode 100644 test/Benchmark/MessagePackCsharp/Benchmark/Serializers/Utf8JsonSerializer.cs
 create mode 100644 test/Benchmark/Readme.md

diff --git a/test/Benchmark/Benchmark.csproj b/test/Benchmark/Benchmark.csproj
new file mode 100644
index 000000000..c6d057c6d
--- /dev/null
+++ b/test/Benchmark/Benchmark.csproj
@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <Nullable>disable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+    <PackageReference Include="Ceras" Version="4.1.7" />
+    <PackageReference Include="FsPickler" Version="5.3.2" />
+    <PackageReference Include="Hyperion" Version="0.9.15" />
+    <PackageReference Include="Jil" Version="2.17.0" />
+    <PackageReference Include="MsgPack.Cli" Version="1.0.1" />
+    <PackageReference Include="MessagePack" Version="2.1.115" />
+    <PackageReference Include="protobuf-net" Version="2.4.6" />
+    <PackageReference Include="SpanJson" Version="3.0.1" />
+    <PackageReference Include="System.Text.Json" Version="4.7.2" />
+    <PackageReference Include="Utf8Json" Version="1.3.7" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\MsgPack.Abstraction\MsgPack.Abstraction.csproj">
+      <Aliases>newmpcli</Aliases>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\MsgPack.Core\MsgPack.Core.csproj">
+      <Aliases>newmpcli</Aliases>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\MsgPack.Json\MsgPack.Json.csproj">
+      <Aliases>newmpcli</Aliases>
+    </ProjectReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="MessagePackCsharp\Benchmark\Serializers\" />
+  </ItemGroup>
+</Project>
diff --git a/test/Benchmark/LICENSE b/test/Benchmark/LICENSE
new file mode 100644
index 000000000..8519f42f4
--- /dev/null
+++ b/test/Benchmark/LICENSE
@@ -0,0 +1,39 @@
+MessagePack for C#
+
+MIT License
+
+Copyright (c) 2017 Yoshifumi Kawai and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+lz4net
+
+Copyright (c) 2013-2017, Milosz Krajewski
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/BenchmarkConfig.cs b/test/Benchmark/MessagePackCsharp/Benchmark/BenchmarkConfig.cs
new file mode 100644
index 000000000..1462ad452
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/BenchmarkConfig.cs
@@ -0,0 +1,190 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Benchmark.Serializers;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.Csv;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
+
+namespace Benchmark
+{
+    public class BenchmarkConfig : ManualConfig
+    {
+        public BenchmarkConfig()
+        {
+			// Add(baseConfig.With(Runtime.Clr).With(Jit.RyuJit).With(Platform.X64));
+			this.AddJob(
+				// run quickly:)
+				Job.ShortRun
+				.WithIterationCount(1)
+				.WithWarmupCount(1)
+				.WithRuntime(CoreRuntime.Core31)
+				.WithJit(Jit.RyuJit)
+				.WithPlatform(Platform.X64)
+			).AddExporter(
+				MarkdownExporter.GitHub,
+				CsvExporter.Default
+			).AddDiagnoser(
+				MemoryDiagnoser.Default
+			).AddColumn(
+				new DataSizeColumn()
+			);
+
+            this.Orderer = new CustomOrderer();
+        }
+
+        public class CustomOrderer : IOrderer
+        {
+            public bool SeparateLogicalGroups => false;
+
+            public IEnumerable<BenchmarkCase> GetExecutionOrder(ImmutableArray<BenchmarkCase> benchmarksCase)
+            {
+                return benchmarksCase;
+            }
+
+            public string GetHighlightGroupKey(BenchmarkCase benchmarkCase)
+            {
+                return benchmarkCase.Descriptor.MethodIndex.ToString();
+            }
+
+            public string GetLogicalGroupKey(ImmutableArray<BenchmarkCase> allBenchmarksCases, BenchmarkCase benchmarkCase)
+            {
+                return null;
+            }
+
+            public IEnumerable<IGrouping<string, BenchmarkCase>> GetLogicalGroupOrder(IEnumerable<IGrouping<string, BenchmarkCase>> logicalGroups)
+            {
+                return logicalGroups;
+            }
+
+            public IEnumerable<BenchmarkCase> GetSummaryOrder(ImmutableArray<BenchmarkCase> benchmarksCases, Summary summary)
+            {
+                return benchmarksCases
+                    .OrderBy(x => x.Descriptor.WorkloadMethod.Name)
+                    .ThenBy(x => x.Parameters.Items.Select(y => y.Value).OfType<SerializerBase>().First().GetType().Name);
+            }
+        }
+
+        public class DataSizeColumn : IColumn
+        {
+            public string Id => "DataSize";
+
+            public string ColumnName => "DataSize";
+
+            public bool AlwaysShow => true;
+
+            public ColumnCategory Category => ColumnCategory.Custom;
+
+            public int PriorityInCategory => int.MaxValue;
+
+            public bool IsNumeric => true;
+
+            public UnitType UnitType => UnitType.Size;
+
+            public string Legend => null;
+
+            public string GetValue(Summary summary, BenchmarkCase benchmarkCase)
+            {
+                return this.GetValue(summary, benchmarkCase, null);
+            }
+
+            public string GetValue(Summary summary, BenchmarkCase benchmarkCase, SummaryStyle style)
+            {
+                System.Reflection.MethodInfo mi = benchmarkCase.Descriptor.WorkloadMethod;
+                if (mi.Name.Contains("Serialize"))
+                {
+                    var instance = Activator.CreateInstance(mi.DeclaringType);
+                    mi.DeclaringType.GetField("Serializer").SetValue(instance, benchmarkCase.Parameters[0].Value);
+                    mi.DeclaringType.GetMethod("Setup").Invoke(instance, null);
+
+                    var bytes = (byte[])mi.Invoke(instance, null);
+                    return ToHumanReadableSize(bytes.Length);
+                }
+                else
+                {
+                    return "-";
+                }
+            }
+
+            public bool IsAvailable(Summary summary)
+            {
+                return true;
+            }
+
+            public bool IsDefault(Summary summary, BenchmarkCase benchmarkCase)
+            {
+                return false;
+            }
+
+            private static string ToHumanReadableSize(long size)
+            {
+                return ToHumanReadableSize(new long?(size));
+            }
+
+            private static string ToHumanReadableSize(long? size)
+            {
+                if (size == null)
+                {
+                    return "NULL";
+                }
+
+                double bytes = size.Value;
+
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " B";
+                }
+
+                bytes = bytes / 1024;
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " KB";
+                }
+
+                bytes = bytes / 1024;
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " MB";
+                }
+
+                bytes = bytes / 1024;
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " GB";
+                }
+
+                bytes = bytes / 1024;
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " TB";
+                }
+
+                bytes = bytes / 1024;
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " PB";
+                }
+
+                bytes = bytes / 1024;
+                if (bytes <= 1024)
+                {
+                    return bytes.ToString("f2") + " EB";
+                }
+
+                bytes = bytes / 1024;
+                return bytes + " ZB";
+            }
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/ExtensionMethods.cs b/test/Benchmark/MessagePackCsharp/Benchmark/ExtensionMethods.cs
new file mode 100644
index 000000000..086187dcf
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/ExtensionMethods.cs
@@ -0,0 +1,153 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Benchmark
+{
+    public static class ExtensionMethods
+    {
+        public static bool TrueEqualsString(this IEnumerable<string> a, IEnumerable<string> b)
+        {
+            return a.SequenceEqual(b);
+        }
+
+        public static bool TrueEqualsString(this string a, string b)
+        {
+            return a == b;
+        }
+
+        public static bool TrueEquals<T>(this T? a, T? b)
+            where T : struct
+        {
+            if (!a.HasValue && !b.HasValue)
+            {
+                return true;
+            }
+
+            if (!a.HasValue)
+            {
+                return false;
+            }
+
+            if (!b.HasValue)
+            {
+                return false;
+            }
+
+            return a.Value.Equals(b.Value);
+        }
+
+        public static bool TrueEquals<T>(this T a, T b)
+            where T : class, IGenericEquality<T>
+        {
+            if (ReferenceEquals(a, null) && ReferenceEquals(b, null))
+            {
+                return true;
+            }
+
+            if (ReferenceEquals(a, null))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(b, null))
+            {
+                return false;
+            }
+
+            return a.Equals(b);
+        }
+
+        public static bool TrueEqualsList<T>(this IEnumerable<T> a, IEnumerable<T> b)
+            where T : class, IGenericEquality<T>
+        {
+            return a.SequenceEqual(b, GenericEqualityComparer<T>.Default);
+        }
+
+        public static bool TrueEqualsListDynamic<T>(this IEnumerable<T> a, IEnumerable<dynamic> b)
+            where T : class, IGenericEquality<T>
+        {
+            if (ReferenceEquals(a, null) && ReferenceEquals(b, null))
+            {
+                return true;
+            }
+
+            if (ReferenceEquals(a, null))
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(b, null))
+            {
+                return false;
+            }
+
+            using (IEnumerator<T> e1 = a.GetEnumerator())
+            using (IEnumerator<dynamic> e2 = b.GetEnumerator())
+            {
+                while (true)
+                {
+                    var e1Next = e1.MoveNext();
+                    var e2Next = e2.MoveNext();
+                    if (e1Next != e2Next)
+                    {
+                        return false;
+                    }
+
+                    if (!e1Next && !e2Next)
+                    {
+                        break;
+                    }
+
+                    T c1 = e1.Current;
+                    dynamic c2 = e2.Current;
+
+                    if (c1 == null && c2 != null)
+                    {
+                        return false;
+                    }
+
+                    if (c2 == null && c1 != null)
+                    {
+                        return false;
+                    }
+
+                    if (!c1.EqualsDynamic(c2))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public static bool IsTypedList(this Type type)
+        {
+            return
+                (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(IList<>)) ||
+                type.GetTypeInfo().GetInterfaces().Any(i =>
+                    i.GetTypeInfo().IsGenericType && i.GetGenericTypeDefinition() == typeof(IList<>));
+        }
+
+        private class GenericEqualityComparer<T> : IEqualityComparer<T>
+            where T : class, IGenericEquality<T>
+        {
+            public static readonly GenericEqualityComparer<T> Default = new GenericEqualityComparer<T>();
+
+            public bool Equals(T x, T y)
+            {
+                return x.TrueEquals(y);
+            }
+
+            public int GetHashCode(T obj)
+            {
+                return 0; // not fast, but not really important here
+            }
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/BooleanValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/BooleanValueFixture.cs
new file mode 100644
index 000000000..dfd0ce6ee
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/BooleanValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class BooleanValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(bool);
+
+        public object Generate()
+        {
+            return this.prng.Next() % 2 == 1;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ByteValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ByteValueFixture.cs
new file mode 100644
index 000000000..9b32dd953
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ByteValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class ByteValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(byte);
+
+        public object Generate()
+        {
+            return (byte)(this.prng.Next() & 0xFF);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeOffsetValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeOffsetValueFixture.cs
new file mode 100644
index 000000000..e12fd57bc
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeOffsetValueFixture.cs
@@ -0,0 +1,20 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class DateTimeOffsetValueFixture : IValueFixture
+    {
+        private long lastValue;
+
+        public Type Type { get; } = typeof(DateTimeOffset);
+
+        public object Generate()
+        {
+            this.lastValue += 1000;
+            return DateTimeOffset.FromUnixTimeMilliseconds(this.lastValue);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeValueFixture.cs
new file mode 100644
index 000000000..0b484c1cc
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DateTimeValueFixture.cs
@@ -0,0 +1,22 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class DateTimeValueFixture : IValueFixture
+    {
+        private long lastValue;
+        private static readonly long Offset = new DateTime(1970, 1, 1, 0, 0, 0).ToFileTime();
+
+        public Type Type { get; } = typeof(DateTime);
+
+        public object Generate()
+        {
+            this.lastValue += 1000;
+            var dt = DateTime.FromFileTime(this.lastValue + Offset);
+            return dt;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DecimalValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DecimalValueFixture.cs
new file mode 100644
index 000000000..89d9dd047
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DecimalValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class DecimalValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(decimal);
+
+        public object Generate()
+        {
+            return this.prng.Next() + 0.66m;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DoubleValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DoubleValueFixture.cs
new file mode 100644
index 000000000..848cbd7e3
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/DoubleValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class DoubleValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(double);
+
+        public object Generate()
+        {
+            return this.prng.Next() + 0.5d;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/EnumValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/EnumValueFixture.cs
new file mode 100644
index 000000000..18e7dd0c2
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/EnumValueFixture.cs
@@ -0,0 +1,26 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class EnumValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+        private readonly string[] values;
+
+        public EnumValueFixture(Type type)
+        {
+            this.Type = type;
+            this.values = Enum.GetNames(this.Type);
+        }
+
+        public Type Type { get; }
+
+        public object Generate()
+        {
+            return Enum.Parse(this.Type, this.values[this.prng.Next(this.values.Length)]);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ExpressionTreeFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ExpressionTreeFixture.cs
new file mode 100644
index 000000000..86c9a6788
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ExpressionTreeFixture.cs
@@ -0,0 +1,255 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Benchmark.Fixture
+{
+    public class ExpressionTreeFixture
+    {
+        private readonly ConcurrentDictionary<Type, Func<int, int, object>> functorCache =
+            new ConcurrentDictionary<Type, Func<int, int, object>>();
+
+        private readonly Dictionary<Type, IValueFixture> valueFixtures = new Dictionary<Type, IValueFixture>();
+
+        public ExpressionTreeFixture()
+        {
+            IValueFixture[] fixtures = new IValueFixture[]
+            {
+                new StringValueFixture(),
+                new IntValueFixture(),
+                new GuidValueFixture(),
+                new DateTimeOffsetValueFixture(),
+                new DateTimeValueFixture(),
+                new BooleanValueFixture(),
+                new DecimalValueFixture(),
+                new LongValueFixture(),
+                new FloatValueFixture(),
+                new DoubleValueFixture(),
+                new ByteValueFixture(),
+                new ShortValueFixture(),
+                new ByteArrayFixture(),
+                new SByteValueFixture(),
+                new UShortValueFixture(),
+                new UInt32ValueFixture(),
+                new UInt64ValueFixture(),
+                new CharValueFixture(),
+            };
+
+            foreach (IValueFixture item in fixtures)
+            {
+                this.valueFixtures.Add(item.Type, item);
+            }
+        }
+
+        public object Create(Type type, int repeatCount = 1, int recursiveCount = 1)
+        {
+            Func<int, int, object> functor = this.functorCache.GetOrAdd(type, this.AddFunctor);
+            return functor(repeatCount, recursiveCount);
+        }
+
+        private Func<int, int, object> AddFunctor(Type type)
+        {
+            ParameterExpression repeatCount = Expression.Parameter(typeof(int), "repeatCount");
+            ParameterExpression recursiveCount = Expression.Parameter(typeof(int), "recursiveCount");
+            var subExpressions = new List<Expression>();
+            ParameterExpression typedOutput = Expression.Variable(type, "typedOutput");
+            if (this.valueFixtures.ContainsKey(type) || type.IsArray || type.IsTypedList())
+            {
+                // they can be generated directly
+                Expression expression = this.GenerateValue(typedOutput, repeatCount, recursiveCount, type);
+                subExpressions.Add(expression);
+            }
+            else
+            {
+                subExpressions.Add(Expression.Assign(typedOutput, Expression.New(type)));
+                PropertyInfo[] typeProps = type.GetProperties();
+                foreach (PropertyInfo propertyInfo in typeProps)
+                {
+                    if (!propertyInfo.CanWrite)
+                    {
+                        continue;
+                    }
+
+                    Type propertyType = propertyInfo.PropertyType;
+                    var isRecursion = this.IsRecursion(type, propertyType) || this.IsRecursion(propertyType, type);
+                    MemberExpression memberAccess = Expression.MakeMemberAccess(typedOutput, propertyInfo);
+                    Expression expression = this.GenerateValue(
+                        memberAccess,
+                        repeatCount,
+                        isRecursion ? Expression.Decrement(recursiveCount) : (Expression)recursiveCount,
+                        propertyType);
+                    subExpressions.Add(expression);
+                }
+            }
+
+            LabelTarget returnTarget = Expression.Label(typeof(object));
+            LabelExpression returnLabel = Expression.Label(returnTarget, Expression.Convert(typedOutput, typeof(object)));
+            subExpressions.Add(returnLabel);
+            BlockExpression block = Expression.Block(new[] { typedOutput }, subExpressions);
+            var lambda = Expression.Lambda<Func<int, int, object>>(block, repeatCount, recursiveCount);
+            return lambda.Compile();
+        }
+
+        private bool IsRecursion(Type parentType, Type type)
+        {
+            if (type == parentType)
+            {
+                return true;
+            }
+
+            if (parentType.IsTypedList())
+            {
+                Type childType = parentType.GetGenericArguments()[0];
+                return this.IsRecursion(type, childType);
+            }
+
+            if (parentType.IsArray)
+            {
+                Type elementType = parentType.GetElementType();
+                return this.IsRecursion(type, elementType);
+            }
+
+            if (Nullable.GetUnderlyingType(parentType) != null)
+            {
+                Type nullableType = Nullable.GetUnderlyingType(parentType);
+                return this.IsRecursion(type, nullableType);
+            }
+
+            return false;
+        }
+
+        private Expression GenerateValue(Expression generatedValue, Expression repeatCount, Expression recursiveCount, Type type)
+        {
+            var result = new List<Expression>();
+            if (this.valueFixtures.TryGetValue(type, out IValueFixture valueFixture))
+            {
+                MethodInfo generateMethodInfo = valueFixture.GetType().GetMethod(nameof(IValueFixture.Generate));
+                result.Add(Expression.Assign(
+                    generatedValue,
+                    Expression.Convert(Expression.Call(Expression.Constant(valueFixture), generateMethodInfo), generatedValue.Type)));
+            }
+            else if (type.IsTypedList())
+            {
+                var expressionList = new List<Expression>();
+                Type elementType = type.GetGenericArguments()[0];
+                expressionList.Add(Expression.Assign(generatedValue, Expression.New(type)));
+                ParameterExpression index = Expression.Parameter(typeof(int), "i");
+                MethodInfo addMi = type.GetMethod("Add", new[] { elementType });
+                ParameterExpression childValue = Expression.Parameter(elementType);
+                var loopBlock = new List<Expression>
+                {
+                    this.GenerateValue(childValue, repeatCount, recursiveCount, elementType),
+                    Expression.Call(generatedValue, addMi, childValue),
+                };
+                if (loopBlock.Count > 0)
+                {
+                    BlockExpression loopContent = Expression.Block(new[] { childValue, index }, loopBlock);
+                    expressionList.Add(ForLoop(index, repeatCount, loopContent));
+                }
+
+                result.Add(this.MakeIfExpression(recursiveCount, expressionList));
+            }
+            else if (type.IsArray)
+            {
+                Type elementType = type.GetElementType();
+                ParameterExpression index = Expression.Parameter(typeof(int), "i");
+                var arrayList = new List<Expression>
+                {
+                    Expression.Assign(generatedValue, Expression.NewArrayBounds(elementType, repeatCount)),
+                    ForLoop(
+                        index,
+                        repeatCount,
+                        this.GenerateValue(Expression.ArrayAccess(generatedValue, index), repeatCount, recursiveCount, elementType)),
+                };
+                result.Add(this.MakeIfExpression(recursiveCount, arrayList));
+            }
+            else if (Nullable.GetUnderlyingType(type) != null)
+            {
+                Type elementType = Nullable.GetUnderlyingType(type);
+                result.Add(this.GenerateValue(generatedValue, repeatCount, recursiveCount, elementType));
+            }
+            else if (type.GetTypeInfo().IsEnum)
+            {
+                if (!this.valueFixtures.TryGetValue(type, out valueFixture))
+                {
+                    valueFixture = new EnumValueFixture(type);
+                    this.valueFixtures.Add(valueFixture.Type, valueFixture);
+                }
+
+                result.Add(this.GenerateValue(generatedValue, repeatCount, recursiveCount, type)); // call again for main method
+            }
+            else
+            {
+                result.Add(this.MakeIfExpression(recursiveCount, this.InvokeCreate(type, generatedValue, repeatCount, recursiveCount)));
+            }
+
+            return result.Count > 1 ? Expression.Block(result) : result.Single();
+        }
+
+        private Expression InvokeCreate(Type type, Expression generatedValue, Expression repeatCount, Expression recursiveCount)
+        {
+            MethodInfo mi = typeof(ExpressionTreeFixture).GetMethod(nameof(this.Create), new[] { typeof(Type), typeof(int), typeof(int) });
+            return Expression.Assign(
+                generatedValue,
+                Expression.Convert(
+                    Expression.Call(Expression.Constant(this), mi, new[] { Expression.Constant(type), repeatCount, recursiveCount }),
+                    generatedValue.Type));
+        }
+
+        private Expression MakeIfExpression(Expression recursiveCount, params Expression[] input)
+        {
+            return Expression.IfThen(
+                Expression.GreaterThanOrEqual(recursiveCount, Expression.Constant(0)),
+                input.Length > 1 ? Expression.Block(input) : input.Single());
+        }
+
+        private Expression MakeIfExpression(Expression recursiveCount, IList<Expression> input)
+        {
+            return Expression.IfThen(
+                Expression.GreaterThanOrEqual(recursiveCount, Expression.Constant(0)),
+                input.Count > 1 ? Expression.Block(input) : input.Single());
+        }
+
+        public T Create<T>(int repeatCount = 1, int recursiveCount = 1)
+        {
+            return (T)this.Create(typeof(T), repeatCount, recursiveCount);
+        }
+
+        public IEnumerable<T> CreateMany<T>(int count, int repeatCount = 1, int recursiveCount = 1)
+        {
+            return this.CreateMany(typeof(T), count, repeatCount, recursiveCount).Cast<T>();
+        }
+
+        public IEnumerable<object> CreateMany(Type type, int count, int repeatCount = 1, int recursiveCount = 1)
+        {
+            Func<int, int, object> functor = this.functorCache.GetOrAdd(type, this.AddFunctor);
+            for (var i = 0; i < count; i++)
+            {
+                yield return functor(repeatCount, recursiveCount);
+            }
+        }
+
+        public static Expression ForLoop(ParameterExpression index, Expression lengthExpression, Expression loopContent)
+        {
+            LabelTarget breakLabel = Expression.Label("LoopBreak");
+            ParameterExpression length = Expression.Variable(typeof(int), "length");
+            BlockExpression block = Expression.Block(
+                new[] { index, length },
+                Expression.Assign(index, Expression.Constant(0)),
+                Expression.Assign(length, lengthExpression),
+                Expression.Loop(
+                    Expression.IfThenElse(
+                        Expression.LessThan(index, length),
+                        Expression.Block(loopContent, Expression.PostIncrementAssign(index)),
+                        Expression.Break(breakLabel)),
+                    breakLabel));
+            return block;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/FloatValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/FloatValueFixture.cs
new file mode 100644
index 000000000..2a88dcc33
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/FloatValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class FloatValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(float);
+
+        public object Generate()
+        {
+            return ((float)this.prng.Next() % 10000) + 0.5f;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/GuidValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/GuidValueFixture.cs
new file mode 100644
index 000000000..7fcdf6558
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/GuidValueFixture.cs
@@ -0,0 +1,17 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class GuidValueFixture : IValueFixture
+    {
+        public Type Type { get; } = typeof(Guid);
+
+        public object Generate()
+        {
+            return Guid.NewGuid();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IValueFixture.cs
new file mode 100644
index 000000000..73d23d46f
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IValueFixture.cs
@@ -0,0 +1,14 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public interface IValueFixture
+    {
+        Type Type { get; }
+
+        object Generate();
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IntValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IntValueFixture.cs
new file mode 100644
index 000000000..1766d881e
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/IntValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class IntValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(int);
+
+        public object Generate()
+        {
+            return this.prng.Next();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/LongValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/LongValueFixture.cs
new file mode 100644
index 000000000..ecc9df160
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/LongValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class LongValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(long);
+
+        public object Generate()
+        {
+            return ((long)this.prng.Next() << 32) | (uint)this.prng.Next();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/OtherPrimitiveFixtures.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/OtherPrimitiveFixtures.cs
new file mode 100644
index 000000000..b73b10e83
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/OtherPrimitiveFixtures.cs
@@ -0,0 +1,71 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+namespace Benchmark.Fixture
+{
+    public delegate T Converter<T>(ReadOnlySpan<byte> buffer);
+
+    public abstract class PrimitiveFixtureBase<T> : IValueFixture
+        where T : unmanaged
+    {
+        private readonly Random rand = new Random();
+
+        public Type Type => typeof(T);
+
+        public abstract object Generate();
+
+        protected unsafe object GenerateBytes(Converter<T> converter)
+        {
+            Span<byte> buffer = stackalloc byte[sizeof(T)];
+            this.rand.NextBytes(buffer);
+            return converter(buffer);
+        }
+    }
+
+    public class SByteValueFixture : PrimitiveFixtureBase<sbyte>
+    {
+        public override object Generate()
+        {
+            return this.GenerateBytes(x => unchecked((sbyte)x[0]));
+        }
+    }
+
+    public class UShortValueFixture : PrimitiveFixtureBase<ushort>
+    {
+        public override object Generate() => this.GenerateBytes(BitConverter.ToUInt16);
+    }
+
+    public class UInt32ValueFixture : PrimitiveFixtureBase<UInt32>
+    {
+        public override object Generate() => this.GenerateBytes(BitConverter.ToUInt32);
+    }
+
+    public class UInt64ValueFixture : PrimitiveFixtureBase<UInt64>
+    {
+        public override object Generate() => this.GenerateBytes(BitConverter.ToUInt64);
+    }
+
+    public class CharValueFixture : PrimitiveFixtureBase<Char>
+    {
+        public override object Generate() => this.GenerateBytes(BitConverter.ToChar);
+    }
+
+    public class ByteArrayFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(byte[]);
+
+        public object Generate()
+        {
+            var bytes = new byte[100];
+            this.prng.NextBytes(bytes);
+            return bytes;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ShortValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ShortValueFixture.cs
new file mode 100644
index 000000000..2b621e1f7
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/ShortValueFixture.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class ShortValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(short);
+
+        public object Generate()
+        {
+            return (short)(this.prng.Next() & 0xFFFF);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/StringValueFixture.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/StringValueFixture.cs
new file mode 100644
index 000000000..a16becbec
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Fixture/StringValueFixture.cs
@@ -0,0 +1,31 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Fixture
+{
+    public class StringValueFixture : IValueFixture
+    {
+        private readonly Random prng = new Random();
+
+        public Type Type { get; } = typeof(string);
+
+        public object Generate()
+        {
+            return this.Generate(8);
+        }
+
+        private string Generate(int length)
+        {
+            const string chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+            var cArray = new char[length];
+            for (var i = 0; i < length; i++)
+            {
+                cArray[i] = chars[this.prng.Next(chars.Length)];
+            }
+
+            return new string(cArray);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/IGenericEquality`1.cs b/test/Benchmark/MessagePackCsharp/Benchmark/IGenericEquality`1.cs
new file mode 100644
index 000000000..81500e3dc
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/IGenericEquality`1.cs
@@ -0,0 +1,12 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Benchmark
+{
+    public interface IGenericEquality<in T>
+    {
+        bool Equals(T obj);
+
+        bool EqualsDynamic(dynamic obj);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/AccessToken.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/AccessToken.cs
new file mode 100644
index 000000000..f7b8f022b
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/AccessToken.cs
@@ -0,0 +1,44 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class AccessToken : IGenericEquality<AccessToken>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string access_token { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public DateTime? expires_on_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? account_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public List<string> scope { get; set; }
+
+        public bool Equals(AccessToken obj)
+        {
+            return
+                this.access_token.TrueEqualsString(obj.access_token) ||
+                this.expires_on_date.TrueEquals(obj.expires_on_date) ||
+                this.account_id.TrueEquals(obj.account_id) ||
+                this.scope.TrueEqualsString(obj.scope);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.access_token.TrueEqualsString((string)obj.access_token) ||
+                this.expires_on_date.TrueEquals((DateTime?)obj.expires_on_date) ||
+                this.account_id.TrueEquals((int?)obj.account_id) ||
+                this.scope.TrueEqualsString((IEnumerable<string>)obj.scope);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/AccountMerge.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/AccountMerge.cs
new file mode 100644
index 000000000..31f777bf7
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/AccountMerge.cs
@@ -0,0 +1,38 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class AccountMerge : IGenericEquality<AccountMerge>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? old_account_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? new_account_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? merge_date { get; set; }
+
+        public bool Equals(AccountMerge obj)
+        {
+            return
+                this.old_account_id.TrueEquals(obj.old_account_id) &&
+                this.new_account_id.TrueEquals(obj.new_account_id) &&
+                this.merge_date.TrueEquals(obj.merge_date);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.old_account_id.TrueEquals((int?)obj.old_account_id) &&
+                this.new_account_id.TrueEquals((int?)obj.new_account_id) &&
+                this.merge_date.TrueEquals((DateTime?)obj.merge_date);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Answer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Answer.cs
new file mode 100644
index 000000000..0b8d997a0
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Answer.cs
@@ -0,0 +1,234 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#pragma warning disable IDE1006
+#pragma warning disable SA1516
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Answer : IGenericEquality<Answer>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? answer_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? locked_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public DateTime? last_edit_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public DateTime? last_activity_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public DateTime? community_owned_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public bool? is_accepted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public ShallowUser owner { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public int? up_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public int? down_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public List<Comment> comments { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(17), MessagePack.Key(17 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(18), MessagePack.Key(18 - 1)]
+        public bool? upvoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(19), MessagePack.Key(19 - 1)]
+        public bool? downvoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(20), MessagePack.Key(20 - 1)]
+        public bool? accepted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(21), MessagePack.Key(21 - 1)]
+        public ShallowUser last_editor { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(22), MessagePack.Key(22 - 1)]
+        public int? comment_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(23), MessagePack.Key(23 - 1)]
+        public string body_markdown { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(24), MessagePack.Key(24 - 1)]
+        public string share_link { get; set; }
+
+        public bool Equals(Answer obj)
+        {
+            return
+                this.accepted.TrueEquals(obj.accepted) &&
+                this.answer_id.TrueEquals(obj.answer_id) &&
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_markdown.TrueEqualsString(obj.body_markdown) &&
+                this.comment_count.TrueEquals(obj.comment_count) &&
+                this.comments.TrueEqualsList(obj.comments) &&
+                this.community_owned_date.TrueEquals(obj.community_owned_date) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.down_vote_count.TrueEquals(obj.down_vote_count) &&
+                this.downvoted.TrueEquals(obj.downvoted) &&
+                this.is_accepted.TrueEquals(obj.is_accepted) &&
+                this.last_activity_date.TrueEquals(obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals(obj.last_edit_date) &&
+                this.last_editor.TrueEquals(obj.last_editor) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.locked_date.TrueEquals(obj.locked_date) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.question_id.TrueEquals(obj.question_id) &&
+                this.score.TrueEquals(obj.score) &&
+                this.share_link.TrueEqualsString(obj.share_link) &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title.TrueEqualsString(obj.title) &&
+                this.up_vote_count.TrueEquals(obj.up_vote_count) &&
+                this.upvoted.TrueEquals(obj.upvoted);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.accepted.TrueEquals((bool?)obj.accepted) &&
+                this.answer_id.TrueEquals((int?)obj.answer_id) &&
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_markdown.TrueEqualsString((string)obj.body_markdown) &&
+                this.comment_count.TrueEquals((int?)obj.comment_count) &&
+                this.comments.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.comments) &&
+                this.community_owned_date.TrueEquals((DateTime?)obj.community_owned_date) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.down_vote_count.TrueEquals((int?)obj.down_vote_count) &&
+                this.downvoted.TrueEquals((bool?)obj.downvoted) &&
+                this.is_accepted.TrueEquals((bool?)obj.is_accepted) &&
+                this.last_activity_date.TrueEquals((DateTime?)obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals((DateTime?)obj.last_edit_date) &&
+                ((this.last_editor == null && obj.last_editor == null) || this.last_editor.EqualsDynamic(obj.last_editor)) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.locked_date.TrueEquals((DateTime?)obj.locked_date) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.question_id.TrueEquals((int?)obj.question_id) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.share_link.TrueEqualsString((string)obj.share_link) &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title.TrueEqualsString((string)obj.title) &&
+                this.up_vote_count.TrueEquals((int?)obj.up_vote_count) &&
+                this.upvoted.TrueEquals((bool?)obj.upvoted);
+        }
+    }
+
+    [MessagePack.MessagePackObject(true)]
+    public class Answer2 : IGenericEquality<Answer2>
+    {
+        public int? question_id { get; set; }
+        public int? answer_id { get; set; }
+        public DateTime? locked_date { get; set; }
+        public DateTime? creation_date { get; set; }
+        public DateTime? last_edit_date { get; set; }
+        public DateTime? last_activity_date { get; set; }
+        public int? score { get; set; }
+        public DateTime? community_owned_date { get; set; }
+        public bool? is_accepted { get; set; }
+        public string body { get; set; }
+        public ShallowUser2 owner { get; set; }
+        public string title { get; set; }
+        public int? up_vote_count { get; set; }
+        public int? down_vote_count { get; set; }
+        public List<Comment2> comments { get; set; }
+        public string link { get; set; }
+        public List<string> tags { get; set; }
+        public bool? upvoted { get; set; }
+        public bool? downvoted { get; set; }
+        public bool? accepted { get; set; }
+        public ShallowUser2 last_editor { get; set; }
+        public int? comment_count { get; set; }
+        public string body_markdown { get; set; }
+        public string share_link { get; set; }
+
+        public bool Equals(Answer2 obj)
+        {
+            return
+                this.accepted.TrueEquals(obj.accepted) &&
+                this.answer_id.TrueEquals(obj.answer_id) &&
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_markdown.TrueEqualsString(obj.body_markdown) &&
+                this.comment_count.TrueEquals(obj.comment_count) &&
+                this.comments.TrueEqualsList(obj.comments) &&
+                this.community_owned_date.TrueEquals(obj.community_owned_date) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.down_vote_count.TrueEquals(obj.down_vote_count) &&
+                this.downvoted.TrueEquals(obj.downvoted) &&
+                this.is_accepted.TrueEquals(obj.is_accepted) &&
+                this.last_activity_date.TrueEquals(obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals(obj.last_edit_date) &&
+                this.last_editor.TrueEquals(obj.last_editor) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.locked_date.TrueEquals(obj.locked_date) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.question_id.TrueEquals(obj.question_id) &&
+                this.score.TrueEquals(obj.score) &&
+                this.share_link.TrueEqualsString(obj.share_link) &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title.TrueEqualsString(obj.title) &&
+                this.up_vote_count.TrueEquals(obj.up_vote_count) &&
+                this.upvoted.TrueEquals(obj.upvoted);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.accepted.TrueEquals((bool?)obj.accepted) &&
+                this.answer_id.TrueEquals((int?)obj.answer_id) &&
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_markdown.TrueEqualsString((string)obj.body_markdown) &&
+                this.comment_count.TrueEquals((int?)obj.comment_count) &&
+                this.comments.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.comments) &&
+                this.community_owned_date.TrueEquals((DateTime?)obj.community_owned_date) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.down_vote_count.TrueEquals((int?)obj.down_vote_count) &&
+                this.downvoted.TrueEquals((bool?)obj.downvoted) &&
+                this.is_accepted.TrueEquals((bool?)obj.is_accepted) &&
+                this.last_activity_date.TrueEquals((DateTime?)obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals((DateTime?)obj.last_edit_date) &&
+                ((this.last_editor == null && obj.last_editor == null) || this.last_editor.EqualsDynamic(obj.last_editor)) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.locked_date.TrueEquals((DateTime?)obj.locked_date) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.question_id.TrueEquals((int?)obj.question_id) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.share_link.TrueEqualsString((string)obj.share_link) &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title.TrueEqualsString((string)obj.title) &&
+                this.up_vote_count.TrueEquals((int?)obj.up_vote_count) &&
+                this.upvoted.TrueEquals((bool?)obj.upvoted);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Badge.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Badge.cs
new file mode 100644
index 000000000..01818df5a
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Badge.cs
@@ -0,0 +1,75 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum BadgeRank : byte
+    {
+        bronze = 3,
+        silver = 2,
+        gold = 1,
+    }
+
+    public enum BadgeType
+    {
+        named = 1,
+        tag_based = 2,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Badge : IGenericEquality<Badge>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? badge_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public BadgeRank? rank { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? award_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public BadgeType? badge_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public ShallowUser user { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public string link { get; set; }
+
+        public bool Equals(Badge obj)
+        {
+            return
+                this.award_count.TrueEquals(obj.award_count) &&
+                this.badge_id.TrueEquals(obj.badge_id) &&
+                this.badge_type.TrueEquals(obj.badge_type) &&
+                this.description.TrueEqualsString(obj.description) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.name.TrueEqualsString(obj.name) &&
+                this.rank.TrueEquals(obj.rank) &&
+                this.user.TrueEquals(obj.user);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.award_count.TrueEquals((int?)obj.award_count) &&
+                this.badge_id.TrueEquals((int?)obj.badge_id) &&
+                this.badge_type.TrueEquals((BadgeType?)obj.badge_type) &&
+                this.description.TrueEqualsString((string)obj.description) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.name.TrueEqualsString((string)obj.name) &&
+                this.rank.TrueEquals((BadgeRank?)obj.rank) &&
+                ((this.user == null && obj.user == null) || this.user.EqualsDynamic(obj.user));
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Comment.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Comment.cs
new file mode 100644
index 000000000..b36aee46a
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Comment.cs
@@ -0,0 +1,145 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#pragma warning disable IDE1006
+#pragma warning disable SA1516
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum PostType : byte
+    {
+        question = 1,
+        answer = 2,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Comment : IGenericEquality<Comment>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? comment_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public PostType? post_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public bool? edited { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public ShallowUser owner { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public ShallowUser reply_to_user { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public string body_markdown { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public bool? upvoted { get; set; }
+
+        public bool Equals(Comment obj)
+        {
+            return
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_markdown.TrueEqualsString(obj.body_markdown) &&
+                this.comment_id.TrueEquals(obj.comment_id) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.edited.TrueEquals(obj.edited) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.reply_to_user.TrueEquals(obj.reply_to_user) &&
+                this.score.TrueEquals(obj.score) &&
+                this.upvoted.TrueEquals(obj.upvoted);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_markdown.TrueEqualsString((string)obj.body_markdown) &&
+                this.comment_id.TrueEquals((int?)obj.comment_id) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.edited.TrueEquals((bool?)obj.edited) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                ((this.reply_to_user == null && obj.reply_to_user == null) ||
+                 this.reply_to_user.EqualsDynamic(obj.reply_to_user)) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.upvoted.TrueEquals((bool?)obj.upvoted);
+        }
+    }
+
+    [MessagePack.MessagePackObject(true)]
+    public class Comment2 : IGenericEquality<Comment2>
+    {
+        public int? comment_id { get; set; }
+        public int? post_id { get; set; }
+        public DateTime? creation_date { get; set; }
+        public PostType? post_type { get; set; }
+        public int? score { get; set; }
+        public bool? edited { get; set; }
+        public string body { get; set; }
+        public ShallowUser2 owner { get; set; }
+        public ShallowUser2 reply_to_user { get; set; }
+        public string link { get; set; }
+        public string body_markdown { get; set; }
+        public bool? upvoted { get; set; }
+
+        public bool Equals(Comment2 obj)
+        {
+            return
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_markdown.TrueEqualsString(obj.body_markdown) &&
+                this.comment_id.TrueEquals(obj.comment_id) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.edited.TrueEquals(obj.edited) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.reply_to_user.TrueEquals(obj.reply_to_user) &&
+                this.score.TrueEquals(obj.score) &&
+                this.upvoted.TrueEquals(obj.upvoted);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_markdown.TrueEqualsString((string)obj.body_markdown) &&
+                this.comment_id.TrueEquals((int?)obj.comment_id) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.edited.TrueEquals((bool?)obj.edited) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                ((this.reply_to_user == null && obj.reply_to_user == null) ||
+                 this.reply_to_user.EqualsDynamic(obj.reply_to_user)) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.upvoted.TrueEquals((bool?)obj.upvoted);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Error.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Error.cs
new file mode 100644
index 000000000..4b19fec54
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Error.cs
@@ -0,0 +1,37 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Error : IGenericEquality<Error>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? error_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string error_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string description { get; set; }
+
+        public bool Equals(Error obj)
+        {
+            return
+                this.error_id.TrueEquals(obj.error_id) &&
+                this.error_name.TrueEqualsString(obj.error_name) &&
+                this.description.TrueEqualsString(obj.description);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.error_id.TrueEquals((int?)obj.error_id) &&
+                this.error_name.TrueEqualsString((string)obj.error_name) &&
+                this.description.TrueEqualsString((string)obj.description);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Event.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Event.cs
new file mode 100644
index 000000000..79599aa42
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Event.cs
@@ -0,0 +1,57 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum EventType : byte
+    {
+        question_posted = 1,
+        answer_posted = 2,
+        comment_posted = 3,
+        post_edited = 4,
+        user_created = 5,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Event : IGenericEquality<Event>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public EventType? event_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? event_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string excerpt { get; set; }
+
+        public bool Equals(Event obj)
+        {
+            return
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.event_id.TrueEquals(obj.event_id) &&
+                this.event_type.TrueEquals(obj.event_type) &&
+                this.excerpt.TrueEqualsString(obj.excerpt) &&
+                this.link.TrueEqualsString(obj.link);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.event_id.TrueEquals((int?)obj.event_id) &&
+                this.event_type.TrueEquals((EventType?)obj.event_type) &&
+                this.excerpt.TrueEqualsString((string)obj.excerpt) &&
+                this.link.TrueEqualsString((string)obj.link);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Feed.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Feed.cs
new file mode 100644
index 000000000..1ceb29798
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Feed.cs
@@ -0,0 +1,693 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System.Collections.Generic;
+using ProtoBuf;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class MobileFeed : IGenericEquality<MobileFeed>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public List<MobileQuestion> hot_questions { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public List<MobileInboxItem> inbox_items { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public List<MobileQuestion> likely_to_answer_questions { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public List<MobileRepChange> reputation_events { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public List<MobileQuestion> cross_site_interesting_questions { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public List<MobileBadgeAward> badges { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public List<MobilePrivilege> earned_privileges { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public List<MobilePrivilege> upcoming_privileges { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public List<MobileCommunityBulletin> community_bulletins { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public List<MobileAssociationBonus> association_bonuses { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public List<MobileCareersJobAd> careers_job_ads { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public List<MobileBannerAd> banner_ads { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public long? before { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public long? since { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public int? account_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public MobileUpdateNotice update_notice { get; set; }
+
+        public bool Equals(MobileFeed obj)
+        {
+            return
+                this.account_id == obj.account_id &&
+                this.association_bonuses.TrueEqualsList(obj.association_bonuses) &&
+                this.badges.TrueEqualsList(obj.badges) &&
+                this.banner_ads.TrueEqualsList(obj.banner_ads) &&
+                this.before == obj.before &&
+                this.careers_job_ads.TrueEqualsList(obj.careers_job_ads) &&
+                this.community_bulletins.TrueEqualsList(obj.community_bulletins) &&
+                this.cross_site_interesting_questions.TrueEqualsList(obj.cross_site_interesting_questions) &&
+                this.earned_privileges.TrueEqualsList(obj.earned_privileges) &&
+                this.hot_questions.TrueEqualsList(obj.hot_questions) &&
+                this.inbox_items.TrueEqualsList(obj.inbox_items) &&
+                this.likely_to_answer_questions.TrueEqualsList(obj.likely_to_answer_questions) &&
+                this.reputation_events.TrueEqualsList(obj.reputation_events) &&
+                this.since == obj.since &&
+                this.upcoming_privileges.TrueEqualsList(obj.upcoming_privileges) &&
+                this.update_notice.TrueEquals(obj.update_notice);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.account_id == (int?)obj.account_id &&
+                this.association_bonuses.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.association_bonuses) &&
+                this.badges.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.badges) &&
+                this.banner_ads.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.banner_ads) &&
+                this.before == (long?)obj.before &&
+                this.careers_job_ads.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.careers_job_ads) &&
+                this.community_bulletins.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.community_bulletins) &&
+                this.cross_site_interesting_questions.TrueEqualsListDynamic(
+                    (IEnumerable<dynamic>)obj.cross_site_interesting_questions) &&
+                this.earned_privileges.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.earned_privileges) &&
+                this.hot_questions.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.hot_questions) &&
+                this.inbox_items.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.inbox_items) &&
+                this.likely_to_answer_questions.TrueEqualsListDynamic(
+                    (IEnumerable<dynamic>)obj.likely_to_answer_questions) &&
+                this.reputation_events.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.reputation_events) &&
+                this.since == (long?)obj.since &&
+                this.upcoming_privileges.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.upcoming_privileges) &&
+                ((this.update_notice == null && obj.update_notice == null) || this.update_notice.EqualsDynamic(obj.update_notice));
+        }
+    }
+
+    public interface IMobileFeedBase<T> : IGenericEquality<T>
+    {
+        int? group_id { get; set; }
+
+        long? added_date { get; set; }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileQuestion : IMobileFeedBase<MobileQuestion>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public long? question_creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public long? last_activity_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public bool? is_deleted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public bool? has_accepted_answer { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileQuestion obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.answer_count == obj.answer_count &&
+                this.group_id == obj.group_id &&
+                this.has_accepted_answer == obj.has_accepted_answer &&
+                this.is_deleted == obj.is_deleted &&
+                this.last_activity_date == obj.last_activity_date &&
+                this.question_creation_date == obj.question_creation_date &&
+                this.question_id == obj.question_id &&
+                this.site == obj.site &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title == obj.title;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.answer_count == (int?)obj.answer_count &&
+                this.group_id == (int?)obj.group_id &&
+                this.has_accepted_answer == (bool?)obj.has_accepted_answer &&
+                this.is_deleted == (bool?)obj.is_deleted &&
+                this.last_activity_date == (long?)obj.last_activity_date &&
+                this.question_creation_date == (long?)obj.question_creation_date &&
+                this.question_id == (int?)obj.question_id &&
+                this.site == (string)obj.site &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title == (string)obj.title;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileRepChange : IMobileFeedBase<MobileRepChange>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? rep_change { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileRepChange obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.group_id == obj.group_id &&
+                this.link == obj.link &&
+                this.rep_change == obj.rep_change &&
+                this.site == obj.site &&
+                this.title == obj.title;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.group_id == (int?)obj.group_id &&
+                this.link == (string)obj.link &&
+                this.rep_change == (int?)obj.rep_change &&
+                this.site == (string)obj.site &&
+                this.title == (string)obj.title;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileInboxItem : IMobileFeedBase<MobileInboxItem>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? answer_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? comment_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public long? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public string item_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileInboxItem obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.answer_id == obj.answer_id &&
+                this.body == obj.body &&
+                this.comment_id == obj.comment_id &&
+                this.creation_date == obj.creation_date &&
+                this.group_id == obj.group_id &&
+                this.item_type == obj.item_type &&
+                this.link == obj.link &&
+                this.question_id == obj.question_id &&
+                this.site == obj.site &&
+                this.title == obj.title;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.answer_id == (int?)obj.answer_id &&
+                this.body == (string)obj.body &&
+                this.comment_id == (int?)obj.comment_id &&
+                this.creation_date == (long?)obj.creation_date &&
+                this.group_id == (int?)obj.group_id &&
+                this.item_type == (string)obj.item_type &&
+                this.link == (string)obj.link &&
+                this.question_id == (int?)obj.question_id &&
+                this.site == (string)obj.site &&
+                this.title == (string)obj.title;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileBadgeAward : IMobileFeedBase<MobileBadgeAward>
+    {
+        public enum BadgeRank : byte
+        {
+            bronze = 1,
+            silver = 2,
+            gold = 3,
+        }
+
+        public enum BadgeType
+        {
+            named = 1,
+            tag_based = 2,
+        }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string badge_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string badge_description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? badge_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public BadgeRank? rank { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public BadgeType? badge_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileBadgeAward obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.badge_description == obj.badge_description &&
+                this.badge_id == obj.badge_id &&
+                this.badge_name == obj.badge_name &&
+                this.badge_type == obj.badge_type &&
+                this.group_id == obj.group_id &&
+                this.link == obj.link &&
+                this.post_id == obj.post_id &&
+                this.rank == obj.rank &&
+                this.site == obj.site;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.badge_description == (string)obj.badge_description &&
+                this.badge_id == (int?)obj.badge_id &&
+                this.badge_name == (string)obj.badge_name &&
+                this.badge_type == (BadgeType?)obj.badge_type &&
+                this.group_id == (int?)obj.group_id &&
+                this.link == (string)obj.link &&
+                this.post_id == (int?)obj.post_id &&
+                this.rank == (BadgeRank?)obj.rank &&
+                this.site == (string)obj.site;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobilePrivilege : IMobileFeedBase<MobilePrivilege>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string privilege_short_description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string privilege_long_description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? privilege_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? reputation_required { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobilePrivilege obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.group_id == obj.group_id &&
+                this.link == obj.link &&
+                this.privilege_id == obj.privilege_id &&
+                this.privilege_long_description == obj.privilege_long_description &&
+                this.privilege_short_description == obj.privilege_short_description &&
+                this.reputation_required == obj.reputation_required &&
+                this.site == obj.site;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.group_id == (int?)obj.group_id &&
+                this.link == (string)obj.link &&
+                this.privilege_id == (int?)obj.privilege_id &&
+                this.privilege_long_description == (string)obj.privilege_long_description &&
+                this.privilege_short_description == (string)obj.privilege_short_description &&
+                this.reputation_required == (int?)obj.reputation_required &&
+                this.site == (string)obj.site;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileCommunityBulletin : IMobileFeedBase<MobileCommunityBulletin>
+    {
+        public enum CommunityBulletinType : byte
+        {
+            blog_post = 1,
+            featured_meta_question = 2,
+            upcoming_event = 3,
+        }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public CommunityBulletinType? bulletin_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public long? begin_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public long? end_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public string custom_date_string { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public bool? is_deleted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public bool? has_accepted_answer { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public bool? is_promoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileCommunityBulletin obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.answer_count == obj.answer_count &&
+                this.begin_date == obj.begin_date &&
+                this.bulletin_type == obj.bulletin_type &&
+                this.custom_date_string == obj.custom_date_string &&
+                this.end_date == obj.end_date &&
+                this.group_id == obj.group_id &&
+                this.has_accepted_answer == obj.has_accepted_answer &&
+                this.is_deleted == obj.is_deleted &&
+                this.is_promoted == obj.is_promoted &&
+                this.link == obj.link &&
+                this.site == obj.site &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title == obj.title;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.answer_count == (int?)obj.answer_count &&
+                this.begin_date == (long?)obj.begin_date &&
+                this.bulletin_type == (CommunityBulletinType?)obj.bulletin_type &&
+                this.custom_date_string == (string)obj.custom_date_string &&
+                this.end_date == (long?)obj.end_date &&
+                this.group_id == (int?)obj.group_id &&
+                this.has_accepted_answer == (bool?)obj.has_accepted_answer &&
+                this.is_deleted == (bool?)obj.is_deleted &&
+                this.is_promoted == (bool?)obj.is_promoted &&
+                this.link == (string)obj.link &&
+                this.site == (string)obj.site &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title == (string)obj.title;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileAssociationBonus : IMobileFeedBase<MobileAssociationBonus>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? amount { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileAssociationBonus obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.amount == obj.amount &&
+                this.group_id == obj.group_id &&
+                this.site == obj.site;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.amount == (int?)obj.amount &&
+                this.group_id == (int?)obj.group_id &&
+                this.site == (string)obj.site;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileCareersJobAd : IMobileFeedBase<MobileCareersJobAd>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? job_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string company_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public string location { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileCareersJobAd obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.company_name == obj.company_name &&
+                this.group_id == obj.group_id &&
+                this.job_id == obj.job_id &&
+                this.link == obj.link &&
+                this.location == obj.location &&
+                this.title == obj.title;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.company_name == (string)obj.company_name &&
+                this.group_id == (int?)obj.group_id &&
+                this.job_id == (int?)obj.job_id &&
+                this.link == (string)obj.link &&
+                this.location == (string)obj.location &&
+                this.title == (string)obj.title;
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileBannerAd : IMobileFeedBase<MobileBannerAd>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public List<MobileBannerAdImage> images { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? group_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public long? added_date { get; set; }
+
+        public bool Equals(MobileBannerAd obj)
+        {
+            return
+                this.added_date == obj.added_date &&
+                this.group_id == obj.group_id &&
+                this.images.TrueEqualsList(obj.images) &&
+                this.link == obj.link;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.added_date == (long?)obj.added_date &&
+                this.group_id == (int?)obj.group_id &&
+                this.images.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.images) &&
+                this.link == (string)obj.link;
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public sealed class MobileBannerAdImage : IGenericEquality<MobileBannerAdImage>
+        {
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public string image_url { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public int? width { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public int? height { get; set; }
+
+            public bool Equals(MobileBannerAdImage obj)
+            {
+                return
+                    this.height == obj.height &&
+                    this.image_url == obj.image_url &&
+                    this.width == obj.width;
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.height == (int?)obj.height &&
+                    this.image_url == (string)obj.image_url &&
+                    this.width == (int?)obj.width;
+            }
+        }
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public sealed class MobileUpdateNotice : IGenericEquality<MobileUpdateNotice>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public bool? should_update { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string message { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string minimum_supported_version { get; set; }
+
+        public bool Equals(MobileUpdateNotice obj)
+        {
+            return
+                this.message == obj.message &&
+                this.minimum_supported_version == obj.minimum_supported_version &&
+                this.should_update == obj.should_update;
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.message == (string)obj.message &&
+                this.minimum_supported_version == (string)obj.minimum_supported_version &&
+                this.should_update == (bool?)obj.should_update;
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/FlagOption.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/FlagOption.cs
new file mode 100644
index 000000000..c2e25f78b
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/FlagOption.cs
@@ -0,0 +1,68 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class FlagOption : IGenericEquality<FlagOption>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? option_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public bool? requires_comment { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public bool? requires_site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public bool? requires_question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public string description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public List<FlagOption> sub_options { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public bool? has_flagged { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? count { get; set; }
+
+        public bool Equals(FlagOption obj)
+        {
+            return
+                this.count.TrueEquals(obj.count) &&
+                this.description.TrueEqualsString(obj.description) &&
+                this.has_flagged.TrueEquals(obj.has_flagged) &&
+                this.option_id.TrueEquals(obj.option_id) &&
+                this.requires_comment.TrueEquals(obj.requires_comment) &&
+                this.requires_question_id.TrueEquals(obj.requires_question_id) &&
+                this.requires_site.TrueEquals(obj.requires_site) &&
+                this.sub_options.TrueEqualsList(obj.sub_options) &&
+                this.title.TrueEqualsString(obj.title);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.count.TrueEquals((int?)obj.count) &&
+                this.description.TrueEqualsString((string)obj.description) &&
+                this.has_flagged.TrueEquals((bool?)obj.has_flagged) &&
+                this.option_id.TrueEquals((int?)obj.option_id) &&
+                this.requires_comment.TrueEquals((bool?)obj.requires_comment) &&
+                this.requires_question_id.TrueEquals((bool?)obj.requires_question_id) &&
+                this.requires_site.TrueEquals((bool?)obj.requires_site) &&
+                this.sub_options.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.sub_options) &&
+                this.title.TrueEqualsString((string)obj.title);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/InboxItem.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/InboxItem.cs
new file mode 100644
index 000000000..8d51d5fcf
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/InboxItem.cs
@@ -0,0 +1,85 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum InboxItemType
+    {
+        comment = 1,
+        chat_message = 2,
+        new_answer = 3,
+        careers_message = 4,
+        careers_invitations = 5,
+        meta_question = 6,
+        post_notice = 7,
+        moderator_message = 8,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class InboxItem : IGenericEquality<InboxItem>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public InboxItemType? item_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? answer_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? comment_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public bool? is_unread { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public Info.Site site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public string link { get; set; }
+
+        public bool Equals(InboxItem obj)
+        {
+            return
+                this.answer_id.TrueEquals(obj.answer_id) &&
+                this.body.TrueEqualsString(obj.body) &&
+                this.comment_id.TrueEquals(obj.comment_id) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.is_unread.TrueEquals(obj.is_unread) &&
+                this.item_type.TrueEquals(obj.item_type) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.question_id.TrueEquals(obj.question_id) &&
+                this.site.TrueEquals(obj.site) &&
+                this.title.TrueEqualsString(obj.title);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.answer_id.TrueEquals((int?)obj.answer_id) &&
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.comment_id.TrueEquals((int?)obj.comment_id) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.is_unread.TrueEquals((bool?)obj.is_unread) &&
+                this.item_type.TrueEquals((InboxItemType?)obj.item_type) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.question_id.TrueEquals((int?)obj.question_id) &&
+                ((this.site == null && obj.site == null) || this.site.EqualsDynamic(obj.site)) &&
+                this.title.TrueEqualsString((string)obj.title);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Info.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Info.cs
new file mode 100644
index 000000000..409595d7e
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Info.cs
@@ -0,0 +1,274 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Info : IGenericEquality<Info>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? total_questions { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? total_unanswered { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? total_accepted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? total_answers { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public decimal? questions_per_minute { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public decimal? answers_per_minute { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? total_comments { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public int? total_votes { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? total_badges { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public decimal? badges_per_minute { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public int? total_users { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public int? new_active_users { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public string api_revision { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public Site site { get; set; }
+
+        public bool Equals(Info obj)
+        {
+            return
+                this.answers_per_minute.TrueEquals(obj.answers_per_minute) &&
+                this.api_revision.TrueEqualsString(obj.api_revision) &&
+                this.badges_per_minute.TrueEquals(obj.badges_per_minute) &&
+                this.new_active_users.TrueEquals(obj.new_active_users) &&
+                this.questions_per_minute.TrueEquals(obj.questions_per_minute) &&
+                this.site.TrueEquals(obj.site) &&
+                this.total_accepted.TrueEquals(obj.total_accepted) &&
+                this.total_answers.TrueEquals(obj.total_answers) &&
+                this.total_badges.TrueEquals(obj.total_badges) &&
+                this.total_comments.TrueEquals(obj.total_comments) &&
+                this.total_questions.TrueEquals(obj.total_questions) &&
+                this.total_unanswered.TrueEquals(obj.total_unanswered) &&
+                this.total_users.TrueEquals(obj.total_users) &&
+                this.total_votes.TrueEquals(obj.total_votes);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.answers_per_minute.TrueEquals((decimal?)obj.answers_per_minute) &&
+                this.api_revision.TrueEqualsString((string)obj.api_revision) &&
+                this.badges_per_minute.TrueEquals((decimal?)obj.badges_per_minute) &&
+                this.new_active_users.TrueEquals((int?)obj.new_active_users) &&
+                this.questions_per_minute.TrueEquals((decimal?)obj.questions_per_minute) &&
+                ((this.site == null && obj.site == null) || this.site.EqualsDynamic(obj.site)) &&
+                this.total_accepted.TrueEquals((int?)obj.total_accepted) &&
+                this.total_answers.TrueEquals((int?)obj.total_answers) &&
+                this.total_badges.TrueEquals((int?)obj.total_badges) &&
+                this.total_comments.TrueEquals((int?)obj.total_comments) &&
+                this.total_questions.TrueEquals((int?)obj.total_questions) &&
+                this.total_unanswered.TrueEquals((int?)obj.total_unanswered) &&
+                this.total_users.TrueEquals((int?)obj.total_users) &&
+                this.total_votes.TrueEquals((int?)obj.total_votes);
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public class Site : IGenericEquality<Site>
+        {
+            public enum SiteState
+            {
+                normal,
+                closed_beta,
+                open_beta,
+                linked_meta,
+            }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public string site_type { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public string name { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public string logo_url { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+            public string api_site_parameter { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+            public string site_url { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+            public string audience { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+            public string icon_url { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+            public List<string> aliases { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+            public SiteState? site_state { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+            public Styling styling { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+            public DateTime? closed_beta_date { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+            public DateTime? open_beta_date { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+            public DateTime? launch_date { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+            public string favicon_url { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+            public List<RelatedSite> related_sites { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+            public string twitter_account { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(17), MessagePack.Key(17 - 1)]
+            public List<string> markdown_extensions { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(18), MessagePack.Key(18 - 1)]
+            public string high_resolution_icon_url { get; set; }
+
+            public bool Equals(Site obj)
+            {
+                return
+                    this.aliases.TrueEqualsString(obj.aliases) &&
+                    this.api_site_parameter.TrueEqualsString(obj.api_site_parameter) &&
+                    this.audience.TrueEqualsString(obj.audience) &&
+                    this.closed_beta_date.TrueEquals(obj.closed_beta_date) &&
+                    this.favicon_url.TrueEqualsString(obj.favicon_url) &&
+                    this.high_resolution_icon_url.TrueEqualsString(obj.high_resolution_icon_url) &&
+                    this.icon_url.TrueEqualsString(obj.icon_url) &&
+                    this.launch_date.TrueEquals(obj.launch_date) &&
+                    this.logo_url.TrueEqualsString(obj.logo_url) &&
+                    this.markdown_extensions.TrueEqualsString(obj.markdown_extensions) &&
+                    this.name.TrueEqualsString(obj.name) &&
+                    this.open_beta_date.TrueEquals(obj.open_beta_date) &&
+                    this.related_sites.TrueEqualsList(obj.related_sites) &&
+                    this.site_state.TrueEquals(obj.site_state) &&
+                    this.site_type.TrueEqualsString(obj.site_type) &&
+                    this.site_url.TrueEqualsString(obj.site_url) &&
+                    this.styling.TrueEquals(obj.styling) &&
+                    this.twitter_account.TrueEqualsString(obj.twitter_account);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.aliases.TrueEqualsString((IEnumerable<string>)obj.aliases) &&
+                    this.api_site_parameter.TrueEqualsString((string)obj.api_site_parameter) &&
+                    this.audience.TrueEqualsString((string)obj.audience) &&
+                    this.closed_beta_date.TrueEquals((DateTime?)obj.closed_beta_date) &&
+                    this.favicon_url.TrueEqualsString((string)obj.favicon_url) &&
+                    this.high_resolution_icon_url.TrueEqualsString((string)obj.high_resolution_icon_url) &&
+                    this.icon_url.TrueEqualsString((string)obj.icon_url) &&
+                    this.launch_date.TrueEquals((DateTime?)obj.launch_date) &&
+                    this.logo_url.TrueEqualsString((string)obj.logo_url) &&
+                    this.markdown_extensions.TrueEqualsString((IEnumerable<string>)obj.markdown_extensions) &&
+                    this.name.TrueEqualsString((string)obj.name) &&
+                    this.open_beta_date.TrueEquals((DateTime?)obj.open_beta_date) &&
+                    this.related_sites.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.related_sites) &&
+                    this.site_state.TrueEquals((SiteState?)obj.site_state) &&
+                    this.site_type.TrueEqualsString((string)obj.site_type) &&
+                    this.site_url.TrueEqualsString((string)obj.site_url) &&
+                    ((this.styling == null && obj.styling == null) || this.styling.EqualsDynamic(obj.styling)) &&
+                    this.twitter_account.TrueEqualsString((string)obj.twitter_account);
+            }
+
+            [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+            public class Styling : IGenericEquality<Styling>
+            {
+                [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+                public string link_color { get; set; }
+
+                [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+                public string tag_foreground_color { get; set; }
+
+                [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+                public string tag_background_color { get; set; }
+
+                public bool Equals(Styling obj)
+                {
+                    return
+                        this.link_color.TrueEqualsString(obj.link_color) &&
+                        this.tag_background_color.TrueEqualsString(obj.tag_background_color) &&
+                        this.tag_foreground_color.TrueEqualsString(obj.tag_foreground_color);
+                }
+
+                public bool EqualsDynamic(dynamic obj)
+                {
+                    return
+                        this.link_color.TrueEqualsString((string)obj.link_color) &&
+                        this.tag_background_color.TrueEqualsString((string)obj.tag_background_color) &&
+                        this.tag_foreground_color.TrueEqualsString((string)obj.tag_foreground_color);
+                }
+            }
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public class RelatedSite : IGenericEquality<RelatedSite>
+        {
+            public enum SiteRelation
+            {
+                parent,
+                meta,
+                chat,
+            }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public string name { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public string site_url { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public SiteRelation? relation { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+            public string api_site_parameter { get; set; }
+
+            public bool Equals(RelatedSite obj)
+            {
+                return
+                    this.name.TrueEqualsString(obj.name) &&
+                    this.relation.TrueEquals(obj.relation) &&
+                    this.api_site_parameter.TrueEqualsString(obj.api_site_parameter);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.name.TrueEqualsString((string)obj.name) &&
+                    this.relation.TrueEquals((SiteRelation?)obj.relation) &&
+                    this.api_site_parameter.TrueEqualsString((string)obj.api_site_parameter);
+            }
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/NetworkUser.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/NetworkUser.cs
new file mode 100644
index 000000000..ec4b2eb4a
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/NetworkUser.cs
@@ -0,0 +1,78 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class NetworkUser : IGenericEquality<NetworkUser>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string site_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string site_url { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? reputation { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? account_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public UserType? user_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public User.BadgeCount badge_counts { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public DateTime? last_access_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public int? question_count { get; set; }
+
+        public bool Equals(NetworkUser obj)
+        {
+            return
+                this.account_id.TrueEquals(obj.account_id) &&
+                this.answer_count.TrueEquals(obj.answer_count) &&
+                this.badge_counts.TrueEquals(obj.badge_counts) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.last_access_date.TrueEquals(obj.last_access_date) &&
+                this.question_count.TrueEquals(obj.question_count) &&
+                this.reputation.TrueEquals(obj.reputation) &&
+                this.site_name.TrueEqualsString(obj.site_name) &&
+                this.site_url.TrueEqualsString(obj.site_url) &&
+                this.user_id.TrueEquals(obj.user_id) &&
+                this.user_type.TrueEquals(obj.user_type);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.account_id.TrueEquals((int?)obj.account_id) &&
+                this.answer_count.TrueEquals((int?)obj.answer_count) &&
+                ((this.badge_counts == null && obj.badge_counts == null) || this.badge_counts.EqualsDynamic(obj.badge_counts)) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.last_access_date.TrueEquals((DateTime?)obj.last_access_date) &&
+                this.question_count.TrueEquals((int?)obj.question_count) &&
+                this.reputation.TrueEquals((int?)obj.reputation) &&
+                this.site_name.TrueEqualsString((string)obj.site_name) &&
+                this.site_url.TrueEqualsString((string)obj.site_url) &&
+                this.user_id.TrueEquals((int?)obj.user_id) &&
+                this.user_type.TrueEquals((UserType?)obj.user_type);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Notification.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Notification.cs
new file mode 100644
index 000000000..09c21f133
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Notification.cs
@@ -0,0 +1,70 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum NotificationType : byte
+    {
+        generic = 1,
+        accounts_associated = 8,
+        badge_earned = 5,
+        profile_activity = 2,
+        bounty_expired = 3,
+        bounty_expires_in_one_day = 4,
+        bounty_expires_in_three_days = 6,
+        edit_suggested = 22,
+        new_privilege = 9,
+        post_migrated = 10,
+        moderator_message = 11,
+        registration_reminder = 12,
+        substantive_edit = 23,
+        reputation_bonus = 7,
+        bounty_grace_period_started = 24,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Notification : IGenericEquality<Notification>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public NotificationType? notification_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public Info.Site site { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public bool? is_unread { get; set; }
+
+        public bool Equals(Notification obj)
+        {
+            return
+                this.body.TrueEqualsString(obj.body) &&
+                this.site.TrueEquals(obj.site) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.is_unread.TrueEquals(obj.is_unread);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.body.TrueEqualsString((string)obj.body) &&
+                ((this.site == null && obj.site == null) || this.site.EqualsDynamic(obj.site)) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.is_unread.TrueEquals((bool?)obj.is_unread);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Post.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Post.cs
new file mode 100644
index 000000000..2f81cbd05
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Post.cs
@@ -0,0 +1,114 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Post : IGenericEquality<Post>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public PostType? post_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public ShallowUser owner { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public DateTime? last_activity_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public DateTime? last_edit_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public int? score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? up_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public int? down_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public List<Comment> comments { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public bool? upvoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public bool? downvoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public ShallowUser last_editor { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public int? comment_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(17), MessagePack.Key(17 - 1)]
+        public string body_markdown { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(18), MessagePack.Key(18 - 1)]
+        public string share_link { get; set; }
+
+        public bool Equals(Post obj)
+        {
+            return
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_markdown.TrueEqualsString(obj.body_markdown) &&
+                this.comment_count.TrueEquals(obj.comment_count) &&
+                this.comments.TrueEqualsList(obj.comments) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.down_vote_count.TrueEquals(obj.down_vote_count) &&
+                this.downvoted.TrueEquals(obj.downvoted) &&
+                this.last_activity_date.TrueEquals(obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals(obj.last_edit_date) &&
+                this.last_editor.TrueEquals(obj.last_editor) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.score.TrueEquals(obj.score) &&
+                this.share_link.TrueEqualsString(obj.share_link) &&
+                this.up_vote_count.TrueEquals(obj.up_vote_count) &&
+                this.upvoted.TrueEquals(obj.upvoted);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_markdown.TrueEqualsString((string)obj.body_markdown) &&
+                this.comment_count.TrueEquals((int?)obj.comment_count) &&
+                this.comments.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.comments) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.down_vote_count.TrueEquals((int?)obj.down_vote_count) &&
+                this.downvoted.TrueEquals((bool?)obj.downvoted) &&
+                this.last_activity_date.TrueEquals((DateTime?)obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals((DateTime?)obj.last_edit_date) &&
+                ((this.last_editor == null && obj.last_editor == null) || this.last_editor.EqualsDynamic(obj.last_editor)) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.share_link.TrueEqualsString((string)obj.share_link) &&
+                this.up_vote_count.TrueEquals((int?)obj.up_vote_count) &&
+                this.upvoted.TrueEquals((bool?)obj.upvoted);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Privilege.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Privilege.cs
new file mode 100644
index 000000000..25dd1725b
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Privilege.cs
@@ -0,0 +1,37 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Privilege : IGenericEquality<Privilege>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string short_description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string description { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? reputation { get; set; }
+
+        public bool Equals(Privilege obj)
+        {
+            return
+                this.description.TrueEqualsString(obj.description) &&
+                this.reputation.TrueEquals(obj.reputation) &&
+                this.short_description.TrueEqualsString(obj.short_description);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.description.TrueEqualsString((string)obj.description) &&
+                this.reputation.TrueEquals((int?)obj.reputation) &&
+                this.short_description.TrueEqualsString((string)obj.short_description);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Question.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Question.cs
new file mode 100644
index 000000000..37fce2ddc
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Question.cs
@@ -0,0 +1,361 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Question : IGenericEquality<Question>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public DateTime? last_edit_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public DateTime? last_activity_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public DateTime? locked_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public DateTime? community_owned_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? accepted_answer_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public MigrationInfo migrated_to { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public MigrationInfo migrated_from { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public DateTime? bounty_closes_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public int? bounty_amount { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public DateTime? closed_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public DateTime? protected_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(17), MessagePack.Key(17 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(18), MessagePack.Key(18 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(19), MessagePack.Key(19 - 1)]
+        public string closed_reason { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(20), MessagePack.Key(20 - 1)]
+        public int? up_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(21), MessagePack.Key(21 - 1)]
+        public int? down_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(22), MessagePack.Key(22 - 1)]
+        public int? favorite_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(23), MessagePack.Key(23 - 1)]
+        public int? view_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(24), MessagePack.Key(24 - 1)]
+        public ShallowUser owner { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(25), MessagePack.Key(25 - 1)]
+        public List<Comment> comments { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(26), MessagePack.Key(26 - 1)]
+        public List<Answer> answers { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(27), MessagePack.Key(27 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(28), MessagePack.Key(28 - 1)]
+        public bool? is_answered { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(29), MessagePack.Key(29 - 1)]
+        public int? close_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(30), MessagePack.Key(30 - 1)]
+        public int? reopen_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(31), MessagePack.Key(31 - 1)]
+        public int? delete_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(32), MessagePack.Key(32 - 1)]
+        public Notice notice { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(33), MessagePack.Key(33 - 1)]
+        public bool? upvoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(34), MessagePack.Key(34 - 1)]
+        public bool? downvoted { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(35), MessagePack.Key(35 - 1)]
+        public bool? favorited { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(36), MessagePack.Key(36 - 1)]
+        public ShallowUser last_editor { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(37), MessagePack.Key(37 - 1)]
+        public int? comment_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(38), MessagePack.Key(38 - 1)]
+        public string body_markdown { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(39), MessagePack.Key(39 - 1)]
+        public ClosedDetails closed_details { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(40), MessagePack.Key(40 - 1)]
+        public string share_link { get; set; }
+
+        public bool Equals(Question obj)
+        {
+            return
+                this.accepted_answer_id.TrueEquals(obj.accepted_answer_id) &&
+                this.answer_count.TrueEquals(obj.answer_count) &&
+                this.answers.TrueEqualsList(obj.answers) &&
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_markdown.TrueEqualsString(obj.body_markdown) &&
+                this.bounty_amount.TrueEquals(obj.bounty_amount) &&
+                this.bounty_closes_date.TrueEquals(obj.bounty_closes_date) &&
+                this.close_vote_count.TrueEquals(obj.close_vote_count) &&
+                this.closed_date.TrueEquals(obj.closed_date) &&
+                this.closed_details.TrueEquals(obj.closed_details) &&
+                this.closed_reason.TrueEqualsString(obj.closed_reason) &&
+                this.comment_count.TrueEquals(obj.comment_count) &&
+                this.comments.TrueEqualsList(obj.comments) &&
+                this.community_owned_date.TrueEquals(obj.community_owned_date) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.delete_vote_count.TrueEquals(obj.delete_vote_count) &&
+                this.down_vote_count.TrueEquals(obj.down_vote_count) &&
+                this.downvoted.TrueEquals(obj.downvoted) &&
+                this.favorite_count.TrueEquals(obj.favorite_count) &&
+                this.favorited.TrueEquals(obj.favorited) &&
+                this.is_answered.TrueEquals(obj.is_answered) &&
+                this.last_activity_date.TrueEquals(obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals(obj.last_edit_date) &&
+                this.last_editor.TrueEquals(obj.last_editor) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.locked_date.TrueEquals(obj.locked_date) &&
+                this.migrated_from.TrueEquals(obj.migrated_from) &&
+                this.migrated_to.TrueEquals(obj.migrated_to) &&
+                this.notice.TrueEquals(obj.notice) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.protected_date.TrueEquals(obj.protected_date) &&
+                this.question_id.TrueEquals(obj.question_id) &&
+                this.reopen_vote_count.TrueEquals(obj.reopen_vote_count) &&
+                this.score.TrueEquals(obj.score) &&
+                this.share_link.TrueEqualsString(obj.share_link) &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title.TrueEqualsString(obj.title) &&
+                this.up_vote_count.TrueEquals(obj.up_vote_count) &&
+                this.upvoted.TrueEquals(obj.upvoted) &&
+                this.view_count.TrueEquals(obj.view_count);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.accepted_answer_id.TrueEquals((int?)obj.accepted_answer_id) &&
+                this.answer_count.TrueEquals((int?)obj.answer_count) &&
+                this.answers.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.answers) &&
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_markdown.TrueEqualsString((string)obj.body_markdown) &&
+                this.bounty_amount.TrueEquals((int?)obj.bounty_amount) &&
+                this.bounty_closes_date.TrueEquals((DateTime?)obj.bounty_closes_date) &&
+                this.close_vote_count.TrueEquals((int?)obj.close_vote_count) &&
+                this.closed_date.TrueEquals((DateTime?)obj.closed_date) &&
+                ((this.closed_details == null && obj.closed_details == null) ||
+                 this.closed_details.EqualsDynamic(obj.closed_details)) &&
+                this.closed_reason.TrueEqualsString((string)obj.closed_reason) &&
+                this.comment_count.TrueEquals((int?)obj.comment_count) &&
+                this.comments.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.comments) &&
+                this.community_owned_date.TrueEquals((DateTime?)obj.community_owned_date) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.delete_vote_count.TrueEquals((int?)obj.delete_vote_count) &&
+                this.down_vote_count.TrueEquals((int?)obj.down_vote_count) &&
+                this.downvoted.TrueEquals((bool?)obj.downvoted) &&
+                this.favorite_count.TrueEquals((int?)obj.favorite_count) &&
+                this.favorited.TrueEquals((bool?)obj.favorited) &&
+                this.is_answered.TrueEquals((bool?)obj.is_answered) &&
+                this.last_activity_date.TrueEquals((DateTime?)obj.last_activity_date) &&
+                this.last_edit_date.TrueEquals((DateTime?)obj.last_edit_date) &&
+                ((this.last_editor == null && obj.last_editor == null) || this.last_editor.EqualsDynamic(obj.last_editor)) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.locked_date.TrueEquals((DateTime?)obj.locked_date) &&
+                ((this.migrated_from == null && obj.migrated_from == null) ||
+                 this.migrated_from.EqualsDynamic(obj.migrated_from)) &&
+                ((this.migrated_to == null && obj.migrated_to == null) || this.migrated_to.EqualsDynamic(obj.migrated_to)) &&
+                ((this.notice == null && obj.notice == null) || this.notice.EqualsDynamic(obj.notice)) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.protected_date.TrueEquals((DateTime?)obj.protected_date) &&
+                this.question_id.TrueEquals((int?)obj.question_id) &&
+                this.reopen_vote_count.TrueEquals((int?)obj.reopen_vote_count) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.share_link.TrueEqualsString((string)obj.share_link) &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title.TrueEqualsString((string)obj.title) &&
+                this.up_vote_count.TrueEquals((int?)obj.up_vote_count) &&
+                this.upvoted.TrueEquals((bool?)obj.upvoted) &&
+                this.view_count.TrueEquals((int?)obj.view_count);
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public class ClosedDetails : IGenericEquality<ClosedDetails>
+        {
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public bool? on_hold { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public string reason { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public string description { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+            public List<ShallowUser> by_users { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+            public List<OriginalQuestion> original_questions { get; set; }
+
+            public bool Equals(ClosedDetails obj)
+            {
+                return
+                    this.by_users.TrueEqualsList(obj.by_users) &&
+                    this.description.TrueEqualsString(obj.description) &&
+                    this.on_hold.TrueEquals(obj.on_hold) &&
+                    this.original_questions.TrueEqualsList(obj.original_questions) &&
+                    this.reason.TrueEqualsString(obj.reason);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                dynamic oq = obj.original_questions;
+                var oqI = (IEnumerable<dynamic>)oq;
+
+                return
+                    this.by_users.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.by_users) &&
+                    this.description.TrueEqualsString((string)obj.description) &&
+                    this.on_hold.TrueEquals((bool?)obj.on_hold) &&
+                    ////this.original_questions.TrueEqualsListDynamic((IEnumerable<dynamic>)obj.original_questions) &&
+                    this.original_questions.TrueEqualsListDynamic(oqI) &&
+                    this.reason.TrueEqualsString((string)obj.reason);
+            }
+
+            [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+            public class OriginalQuestion : IGenericEquality<OriginalQuestion>
+            {
+                [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+                public int? question_id { get; set; }
+
+                [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+                public string title { get; set; }
+
+                [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+                public int? answer_count { get; set; }
+
+                [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+                public int? accepted_answer_id { get; set; }
+
+                public bool Equals(OriginalQuestion obj)
+                {
+                    return
+                        this.accepted_answer_id.TrueEquals(obj.accepted_answer_id) &&
+                        this.answer_count.TrueEquals(obj.answer_count) &&
+                        this.question_id.TrueEquals(obj.question_id) &&
+                        this.title.TrueEqualsString(obj.title);
+                }
+
+                public bool EqualsDynamic(dynamic obj)
+                {
+                    return
+                        this.accepted_answer_id.TrueEquals((int?)obj.accepted_answer_id) &&
+                        this.answer_count.TrueEquals((int?)obj.answer_count) &&
+                        this.question_id.TrueEquals((int?)obj.question_id) &&
+                        this.title.TrueEqualsString((string)obj.title);
+                }
+            }
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public class Notice : IGenericEquality<Notice>
+        {
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public string body { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public DateTime? creation_date { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public int? owner_user_id { get; set; }
+
+            public bool Equals(Notice obj)
+            {
+                return
+                    this.body.TrueEqualsString(obj.body) &&
+                    this.creation_date.TrueEquals(obj.creation_date) &&
+                    this.owner_user_id.TrueEquals(obj.owner_user_id);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.body.TrueEqualsString((string)obj.body) &&
+                    this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                    this.owner_user_id.TrueEquals((int?)obj.owner_user_id);
+            }
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public class MigrationInfo : IGenericEquality<MigrationInfo>
+        {
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public int? question_id { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public Info.Site other_site { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public DateTime? on_date { get; set; }
+
+            public bool Equals(MigrationInfo obj)
+            {
+                return
+                    this.on_date.TrueEquals(obj.on_date) &&
+                    this.other_site.TrueEquals(obj.other_site) &&
+                    this.question_id.TrueEquals(obj.question_id);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.on_date.TrueEquals((DateTime?)obj.on_date) &&
+                    ((this.other_site == null && obj.other_site == null) || this.other_site.EqualsDynamic(obj.other_site)) &&
+                    this.question_id.TrueEquals((int?)obj.question_id);
+            }
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/QuestionTimeline.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/QuestionTimeline.cs
new file mode 100644
index 000000000..76f1f2b94
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/QuestionTimeline.cs
@@ -0,0 +1,85 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum QuestionTimelineAction : byte
+    {
+        question = 1,
+        answer = 2,
+        comment = 3,
+        unaccepted_answer = 4,
+        accepted_answer = 5,
+        vote_aggregate = 6,
+        revision = 7,
+        post_state_changed = 8,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class QuestionTimeline : IGenericEquality<QuestionTimeline>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public QuestionTimelineAction? timeline_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? comment_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string revision_guid { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? up_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? down_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public ShallowUser user { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public ShallowUser owner { get; set; }
+
+        public bool Equals(QuestionTimeline obj)
+        {
+            return
+                this.comment_id.TrueEquals(obj.comment_id) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.down_vote_count.TrueEquals(obj.down_vote_count) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.question_id.TrueEquals(obj.question_id) &&
+                this.revision_guid.TrueEqualsString(obj.revision_guid) &&
+                this.timeline_type.TrueEquals(obj.timeline_type) &&
+                this.up_vote_count.TrueEquals(obj.up_vote_count) &&
+                this.user.TrueEquals(obj.user);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.comment_id.TrueEquals((int?)obj.comment_id) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.down_vote_count.TrueEquals((int?)obj.down_vote_count) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.question_id.TrueEquals((int?)obj.question_id) &&
+                this.revision_guid.TrueEqualsString((string)obj.revision_guid) &&
+                this.timeline_type.TrueEquals((QuestionTimelineAction?)obj.timeline_type) &&
+                this.up_vote_count.TrueEquals((int?)obj.up_vote_count) &&
+                ((this.user == null && obj.user == null) || this.user.EqualsDynamic(obj.user));
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Reputation.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Reputation.cs
new file mode 100644
index 000000000..7f032c73f
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Reputation.cs
@@ -0,0 +1,74 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum VoteType : byte
+    {
+        up_votes = 2,
+        down_votes = 3,
+        spam = 12,
+        accepts = 1,
+        bounties_won = 9,
+        bounties_offered = 8,
+        suggested_edits = 16,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Reputation : IGenericEquality<Reputation>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public PostType? post_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public VoteType? vote_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? reputation_change { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public DateTime? on_date { get; set; }
+
+        public bool Equals(Reputation obj)
+        {
+            return
+                this.link.TrueEqualsString(obj.link) &&
+                this.on_date.TrueEquals(obj.on_date) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.reputation_change.TrueEquals(obj.reputation_change) &&
+                this.title.TrueEqualsString(obj.title) &&
+                this.user_id.TrueEquals(obj.user_id) &&
+                this.vote_type.TrueEquals(obj.vote_type);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.on_date.TrueEquals((DateTime?)obj.on_date) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                this.reputation_change.TrueEquals((int?)obj.reputation_change) &&
+                this.title.TrueEqualsString((string)obj.title) &&
+                this.user_id.TrueEquals((int?)obj.user_id) &&
+                this.vote_type.TrueEquals((VoteType?)obj.vote_type);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/ReputationHistory.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/ReputationHistory.cs
new file mode 100644
index 000000000..3e43eb422
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/ReputationHistory.cs
@@ -0,0 +1,85 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class ReputationHistory : IGenericEquality<ReputationHistory>
+    {
+        public enum ReputationHistoryType : byte
+        {
+            asker_accepts_answer = 1,
+            asker_unaccept_answer = 2,
+            answer_accepted = 3,
+            answer_unaccepted = 4,
+
+            voter_downvotes = 5,
+            voter_undownvotes = 6,
+            post_downvoted = 7,
+            post_undownvoted = 8,
+
+            post_upvoted = 9,
+            post_unupvoted = 10,
+
+            suggested_edit_approval_received = 11,
+
+            post_flagged_as_spam = 12,
+            post_flagged_as_offensive = 13,
+
+            bounty_given = 14,
+            bounty_earned = 15,
+            bounty_cancelled = 16,
+
+            post_deleted = 17,
+            post_undeleted = 18,
+
+            association_bonus = 19,
+            arbitrary_reputation_change = 20,
+
+            vote_fraud_reversal = 21,
+
+            post_migrated = 22,
+
+            user_deleted = 23,
+        }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? reputation_change { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public ReputationHistoryType? reputation_history_type { get; set; }
+
+        public bool Equals(ReputationHistory obj)
+        {
+            return
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.reputation_change.TrueEquals(obj.reputation_change) &&
+                this.reputation_history_type.TrueEquals(obj.reputation_history_type) &&
+                this.user_id.TrueEquals(obj.user_id);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.reputation_change.TrueEquals((int?)obj.reputation_change) &&
+                this.reputation_history_type.TrueEquals((ReputationHistoryType?)obj.reputation_history_type) &&
+                this.user_id.TrueEquals((int?)obj.user_id);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Revision.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Revision.cs
new file mode 100644
index 000000000..1a4588773
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Revision.cs
@@ -0,0 +1,110 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum RevisionType : byte
+    {
+        single_user = 1,
+        vote_based = 2,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Revision : IGenericEquality<Revision>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string revision_guid { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? revision_number { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public RevisionType? revision_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public PostType? post_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public string comment { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public bool? is_rollback { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public string last_body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public string last_title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public List<string> last_tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public bool? set_community_wiki { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public ShallowUser user { get; set; }
+
+        public bool Equals(Revision obj)
+        {
+            return
+                this.body.TrueEqualsString(obj.body) &&
+                this.comment.TrueEqualsString(obj.comment) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.is_rollback.TrueEquals(obj.is_rollback) &&
+                this.last_body.TrueEqualsString(obj.last_body) &&
+                this.last_tags.TrueEqualsString(obj.last_tags) &&
+                this.last_title.TrueEqualsString(obj.last_title) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.revision_guid.TrueEqualsString(obj.revision_guid) &&
+                this.revision_number.TrueEquals(obj.revision_number) &&
+                this.revision_type.TrueEquals(obj.revision_type) &&
+                this.set_community_wiki.TrueEquals(obj.set_community_wiki) &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title.TrueEqualsString(obj.title) &&
+                this.user.TrueEquals(obj.user);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.comment.TrueEqualsString((string)obj.comment) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.is_rollback.TrueEquals((bool?)obj.is_rollback) &&
+                this.last_body.TrueEqualsString((string)obj.last_body) &&
+                this.last_tags.TrueEqualsString((IEnumerable<string>)obj.last_tags) &&
+                this.last_title.TrueEqualsString((string)obj.last_title) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                this.revision_guid.TrueEqualsString((string)obj.revision_guid) &&
+                this.revision_number.TrueEquals((int?)obj.revision_number) &&
+                this.revision_type.TrueEquals((RevisionType?)obj.revision_type) &&
+                this.set_community_wiki.TrueEquals((bool?)obj.set_community_wiki) &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title.TrueEqualsString((string)obj.title) &&
+                ((this.user == null && obj.user == null) || this.user.EqualsDynamic(obj.user));
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/SearchExcerpt.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/SearchExcerpt.cs
new file mode 100644
index 000000000..b08ecfcb0
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/SearchExcerpt.cs
@@ -0,0 +1,123 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+#pragma warning disable SA1300 // Element should begin with upper-case letter
+
+namespace Benchmark.Models
+{
+    public enum SearchExcerptItemType : byte
+    {
+        question = 1,
+        answer = 2,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class SearchExcerpt : IGenericEquality<SearchExcerpt>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string excerpt { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? community_owned_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public DateTime? locked_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public DateTime? last_activity_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public ShallowUser owner { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public ShallowUser last_activity_user { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public SearchExcerptItemType? item_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public int? question_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public bool? is_answered { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public DateTime? closed_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(17), MessagePack.Key(17 - 1)]
+        public int? answer_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(18), MessagePack.Key(18 - 1)]
+        public bool? is_accepted { get; set; }
+
+        public bool Equals(SearchExcerpt obj)
+        {
+            return
+                this.answer_count.TrueEquals(obj.answer_count) &&
+                this.answer_id.TrueEquals(obj.answer_id) &&
+                this.body.TrueEqualsString(obj.body) &&
+                this.closed_date.TrueEquals(obj.closed_date) &&
+                this.community_owned_date.TrueEquals(obj.community_owned_date) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.excerpt.TrueEqualsString(obj.excerpt) &&
+                this.is_accepted.TrueEquals(obj.is_accepted) &&
+                this.is_answered.TrueEquals(obj.is_answered) &&
+                this.item_type.TrueEquals(obj.item_type) &&
+                this.last_activity_date.TrueEquals(obj.last_activity_date) &&
+                this.last_activity_user.TrueEquals(obj.last_activity_user) &&
+                this.locked_date.TrueEquals(obj.locked_date) &&
+                this.owner.TrueEquals(obj.owner) &&
+                this.question_id.TrueEquals(obj.question_id) &&
+                this.score.TrueEquals(obj.score) &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title.TrueEqualsString(obj.title);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.answer_count.TrueEquals((int?)obj.answer_count) &&
+                this.answer_id.TrueEquals((int?)obj.answer_id) &&
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.closed_date.TrueEquals((DateTime?)obj.closed_date) &&
+                this.community_owned_date.TrueEquals((DateTime?)obj.community_owned_date) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.excerpt.TrueEqualsString((string)obj.excerpt) &&
+                this.is_accepted.TrueEquals((bool?)obj.is_accepted) &&
+                this.is_answered.TrueEquals((bool?)obj.is_answered) &&
+                this.item_type.TrueEquals((SearchExcerptItemType?)obj.item_type) &&
+                this.last_activity_date.TrueEquals((DateTime?)obj.last_activity_date) &&
+                ((this.last_activity_user == null && obj.last_activity_user == null) ||
+                 this.last_activity_user.EqualsDynamic(obj.last_activity_user)) &&
+                this.locked_date.TrueEquals((DateTime?)obj.locked_date) &&
+                ((this.owner == null && obj.owner == null) || this.owner.EqualsDynamic(obj.owner)) &&
+                this.question_id.TrueEquals((int?)obj.question_id) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title.TrueEqualsString((string)obj.title);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/ShallowUser.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/ShallowUser.cs
new file mode 100644
index 000000000..c0371d7bb
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/ShallowUser.cs
@@ -0,0 +1,112 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#pragma warning disable IDE1006
+#pragma warning disable SA1516
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum UserType : byte
+    {
+        unregistered = 2,
+        registered = 3,
+        moderator = 4,
+        does_not_exist = 255,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class ShallowUser : IGenericEquality<ShallowUser>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string display_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? reputation { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public UserType? user_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string profile_image { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? accept_rate { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public User.BadgeCount badge_counts { get; set; }
+
+        public bool Equals(ShallowUser obj)
+        {
+            return
+                this.accept_rate.TrueEquals(obj.accept_rate) &&
+                this.badge_counts.TrueEquals(obj.badge_counts) &&
+                this.display_name.TrueEqualsString(obj.display_name) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.profile_image.TrueEqualsString(obj.profile_image) &&
+                this.reputation.TrueEquals(obj.reputation) &&
+                this.user_id.TrueEquals(obj.user_id) &&
+                this.user_type.TrueEquals(obj.user_type);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.accept_rate.TrueEquals((int?)obj.accept_rate) &&
+                ((this.badge_counts == null && obj.badge_counts == null) || this.badge_counts.EqualsDynamic(obj.badge_counts)) &&
+                this.display_name.TrueEqualsString((string)obj.display_name) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.profile_image.TrueEqualsString((string)obj.profile_image) &&
+                this.reputation.TrueEquals((int?)obj.reputation) &&
+                this.user_id.TrueEquals((int?)obj.user_id) &&
+                this.user_type.TrueEquals((UserType?)obj.user_type);
+        }
+    }
+
+    [MessagePack.MessagePackObject(true)]
+    public class ShallowUser2 : IGenericEquality<ShallowUser2>
+    {
+        public int? user_id { get; set; }
+        public string display_name { get; set; }
+        public int? reputation { get; set; }
+        public UserType? user_type { get; set; }
+        public string profile_image { get; set; }
+        public string link { get; set; }
+        public int? accept_rate { get; set; }
+        public User.BadgeCount2 badge_counts { get; set; }
+
+        public bool Equals(ShallowUser2 obj)
+        {
+            return
+                this.accept_rate.TrueEquals(obj.accept_rate) &&
+                this.badge_counts.TrueEquals(obj.badge_counts) &&
+                this.display_name.TrueEqualsString(obj.display_name) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.profile_image.TrueEqualsString(obj.profile_image) &&
+                this.reputation.TrueEquals(obj.reputation) &&
+                this.user_id.TrueEquals(obj.user_id) &&
+                this.user_type.TrueEquals(obj.user_type);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.accept_rate.TrueEquals((int?)obj.accept_rate) &&
+                ((this.badge_counts == null && obj.badge_counts == null) || this.badge_counts.EqualsDynamic(obj.badge_counts)) &&
+                this.display_name.TrueEqualsString((string)obj.display_name) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.profile_image.TrueEqualsString((string)obj.profile_image) &&
+                this.reputation.TrueEquals((int?)obj.reputation) &&
+                this.user_id.TrueEquals((int?)obj.user_id) &&
+                this.user_type.TrueEquals((UserType?)obj.user_type);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/SuggestedEdit.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/SuggestedEdit.cs
new file mode 100644
index 000000000..caaafcef6
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/SuggestedEdit.cs
@@ -0,0 +1,80 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class SuggestedEdit : IGenericEquality<SuggestedEdit>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? suggested_edit_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public PostType? post_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public List<string> tags { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public string comment { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public DateTime? approval_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public DateTime? rejection_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public ShallowUser proposing_user { get; set; }
+
+        public bool Equals(SuggestedEdit obj)
+        {
+            return
+                this.approval_date.TrueEquals(obj.approval_date) &&
+                this.body.TrueEqualsString(obj.body) &&
+                this.comment.TrueEqualsString(obj.comment) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.proposing_user.TrueEquals(obj.proposing_user) &&
+                this.rejection_date.TrueEquals(obj.rejection_date) &&
+                this.suggested_edit_id.TrueEquals(obj.suggested_edit_id) &&
+                this.tags.TrueEqualsString(obj.tags) &&
+                this.title.TrueEqualsString(obj.title);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.approval_date.TrueEquals((DateTime?)obj.approval_date) &&
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.comment.TrueEqualsString((string)obj.comment) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                ((this.proposing_user == null && obj.proposing_user == null) ||
+                 this.proposing_user.EqualsDynamic(obj.proposing_user)) &&
+                this.rejection_date.TrueEquals((DateTime?)obj.rejection_date) &&
+                this.suggested_edit_id.TrueEquals((int?)obj.suggested_edit_id) &&
+                this.tags.TrueEqualsString((IEnumerable<string>)obj.tags) &&
+                this.title.TrueEqualsString((string)obj.title);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/Tag.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Tag.cs
new file mode 100644
index 000000000..60164f344
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/Tag.cs
@@ -0,0 +1,64 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections.Generic;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class Tag : IGenericEquality<Tag>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public bool? is_required { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public bool? is_moderator_only { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public bool? has_synonyms { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public DateTime? last_activity_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public List<string> synonyms { get; set; }
+
+        public bool Equals(Tag obj)
+        {
+            return
+                this.count.TrueEquals(obj.count) &&
+                this.has_synonyms.TrueEquals(obj.has_synonyms) &&
+                this.is_moderator_only.TrueEquals(obj.is_moderator_only) &&
+                this.is_required.TrueEquals(obj.is_required) &&
+                this.last_activity_date.TrueEquals(obj.last_activity_date) &&
+                this.name.TrueEqualsString(obj.name) &&
+                this.synonyms.TrueEqualsString(obj.synonyms) &&
+                this.user_id.TrueEquals(obj.user_id);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.count.TrueEquals((int?)obj.count) &&
+                this.has_synonyms.TrueEquals((bool?)obj.has_synonyms) &&
+                this.is_moderator_only.TrueEquals((bool?)obj.is_moderator_only) &&
+                this.is_required.TrueEquals((bool?)obj.is_required) &&
+                this.last_activity_date.TrueEquals((DateTime?)obj.last_activity_date) &&
+                this.name.TrueEqualsString((string)obj.name) &&
+                this.synonyms.TrueEqualsString((IEnumerable<string>)obj.synonyms) &&
+                this.user_id.TrueEquals((int?)obj.user_id);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagScore.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagScore.cs
new file mode 100644
index 000000000..a7e7b225d
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagScore.cs
@@ -0,0 +1,37 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class TagScore : IGenericEquality<TagScore>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public ShallowUser user { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? post_count { get; set; }
+
+        public bool Equals(TagScore obj)
+        {
+            return
+                this.post_count.TrueEquals(obj.post_count) &&
+                this.score.TrueEquals(obj.score) &&
+                this.user.TrueEquals(obj.user);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.post_count.TrueEquals((int?)obj.post_count) &&
+                this.score.TrueEquals((int?)obj.score) &&
+                ((this.user == null && obj.user == null) || this.user.EqualsDynamic(obj.user));
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagSynonym.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagSynonym.cs
new file mode 100644
index 000000000..8006725e2
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagSynonym.cs
@@ -0,0 +1,48 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class TagSynonym : IGenericEquality<TagSynonym>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string from_tag { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string to_tag { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? applied_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public DateTime? last_applied_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        public bool Equals(TagSynonym obj)
+        {
+            return
+                this.applied_count.TrueEquals(obj.applied_count) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.from_tag.TrueEqualsString(obj.from_tag) &&
+                this.last_applied_date.TrueEquals(obj.last_applied_date) &&
+                this.to_tag.TrueEqualsString(obj.to_tag);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.applied_count.TrueEquals((int?)obj.applied_count) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.from_tag.TrueEqualsString((string)obj.from_tag) &&
+                this.last_applied_date.TrueEquals((DateTime?)obj.last_applied_date) &&
+                this.to_tag.TrueEqualsString((string)obj.to_tag);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagWiki.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagWiki.cs
new file mode 100644
index 000000000..3fb7d2bcc
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TagWiki.cs
@@ -0,0 +1,60 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class TagWiki : IGenericEquality<TagWiki>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string tag_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string body { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public string excerpt { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public DateTime? body_last_edit_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public DateTime? excerpt_last_edit_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public ShallowUser last_body_editor { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public ShallowUser last_excerpt_editor { get; set; }
+
+        public bool Equals(TagWiki obj)
+        {
+            return
+                this.body.TrueEqualsString(obj.body) &&
+                this.body_last_edit_date.TrueEquals(obj.body_last_edit_date) &&
+                this.excerpt.TrueEqualsString(obj.excerpt) &&
+                this.excerpt_last_edit_date.TrueEquals(obj.excerpt_last_edit_date) &&
+                this.last_body_editor.TrueEquals(obj.last_body_editor) &&
+                this.last_excerpt_editor.TrueEquals(obj.last_excerpt_editor) &&
+                this.tag_name.TrueEqualsString(obj.tag_name);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.body.TrueEqualsString((string)obj.body) &&
+                this.body_last_edit_date.TrueEquals((DateTime?)obj.body_last_edit_date) &&
+                this.excerpt.TrueEqualsString((string)obj.excerpt) &&
+                this.excerpt_last_edit_date.TrueEquals((DateTime?)obj.excerpt_last_edit_date) &&
+                ((this.last_body_editor == null && obj.last_body_editor == null) ||
+                 this.last_body_editor.EqualsDynamic(obj.last_body_editor)) &&
+                ((this.last_excerpt_editor == null && obj.last_excerpt_editor == null) ||
+                 this.last_excerpt_editor.EqualsDynamic(obj.last_excerpt_editor)) &&
+                this.tag_name.TrueEqualsString((string)obj.tag_name);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/TopTag.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TopTag.cs
new file mode 100644
index 000000000..5776f4978
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/TopTag.cs
@@ -0,0 +1,52 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class TopTag : IGenericEquality<TopTag>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public string tag_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public int? question_score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public int? question_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? answer_score { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? user_id { get; set; }
+
+        public bool Equals(TopTag obj)
+        {
+            return
+                this.answer_count.TrueEquals(obj.answer_count) &&
+                this.answer_score.TrueEquals(obj.answer_score) &&
+                this.question_count.TrueEquals(obj.question_count) &&
+                this.question_score.TrueEquals(obj.question_score) &&
+                this.tag_name.TrueEqualsString(obj.tag_name) &&
+                this.user_id.TrueEquals(obj.user_id);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.answer_count.TrueEquals((int?)obj.answer_count) &&
+                this.answer_score.TrueEquals((int?)obj.answer_score) &&
+                this.question_count.TrueEquals((int?)obj.question_count) &&
+                this.question_score.TrueEquals((int?)obj.question_score) &&
+                this.tag_name.TrueEqualsString((string)obj.tag_name) &&
+                this.user_id.TrueEquals((int?)obj.user_id);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/User.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/User.cs
new file mode 100644
index 000000000..e55106802
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/User.cs
@@ -0,0 +1,219 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#pragma warning disable IDE1006
+#pragma warning disable SA1516
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class User : IGenericEquality<User>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public UserType? user_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public string display_name { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public string profile_image { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? reputation { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? reputation_change_day { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public int? reputation_change_week { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public int? reputation_change_month { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public int? reputation_change_quarter { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public int? reputation_change_year { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(12), MessagePack.Key(12 - 1)]
+        public int? age { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(13), MessagePack.Key(13 - 1)]
+        public DateTime? last_access_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(14), MessagePack.Key(14 - 1)]
+        public DateTime? last_modified_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(15), MessagePack.Key(15 - 1)]
+        public bool? is_employee { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(16), MessagePack.Key(16 - 1)]
+        public string link { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(17), MessagePack.Key(17 - 1)]
+        public string website_url { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(18), MessagePack.Key(18 - 1)]
+        public string location { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(19), MessagePack.Key(19 - 1)]
+        public int? account_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(20), MessagePack.Key(20 - 1)]
+        public DateTime? timed_penalty_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(21), MessagePack.Key(21 - 1)]
+        public BadgeCount badge_counts { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(22), MessagePack.Key(22 - 1)]
+        public int? question_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(23), MessagePack.Key(23 - 1)]
+        public int? answer_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(24), MessagePack.Key(24 - 1)]
+        public int? up_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(25), MessagePack.Key(25 - 1)]
+        public int? down_vote_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(26), MessagePack.Key(26 - 1)]
+        public string about_me { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(27), MessagePack.Key(27 - 1)]
+        public int? view_count { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(28), MessagePack.Key(28 - 1)]
+        public int? accept_rate { get; set; }
+
+        public bool Equals(User obj)
+        {
+            return
+                this.about_me.TrueEqualsString(obj.about_me) &&
+                this.accept_rate.TrueEquals(obj.accept_rate) &&
+                this.account_id.TrueEquals(obj.account_id) &&
+                this.age.TrueEquals(obj.age) &&
+                this.answer_count.TrueEquals(obj.answer_count) &&
+                this.badge_counts.TrueEquals(obj.badge_counts) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.display_name.TrueEqualsString(obj.display_name) &&
+                this.down_vote_count.TrueEquals(obj.down_vote_count) &&
+                this.is_employee.TrueEquals(obj.is_employee) &&
+                this.last_access_date.TrueEquals(obj.last_access_date) &&
+                this.last_modified_date.TrueEquals(obj.last_modified_date) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.location.TrueEqualsString(obj.location) &&
+                this.profile_image.TrueEqualsString(obj.profile_image) &&
+                this.question_count.TrueEquals(obj.question_count) &&
+                this.reputation.TrueEquals(obj.reputation) &&
+                this.reputation_change_day.TrueEquals(obj.reputation_change_day) &&
+                this.reputation_change_month.TrueEquals(obj.reputation_change_month) &&
+                this.reputation_change_quarter.TrueEquals(obj.reputation_change_quarter) &&
+                this.reputation_change_week.TrueEquals(obj.reputation_change_week) &&
+                this.reputation_change_year.TrueEquals(obj.reputation_change_year) &&
+                this.timed_penalty_date.TrueEquals(obj.timed_penalty_date) &&
+                this.up_vote_count.TrueEquals(obj.up_vote_count) &&
+                this.user_id.TrueEquals(obj.user_id) &&
+                this.user_type.TrueEquals(obj.user_type) &&
+                this.view_count.TrueEquals(obj.view_count) &&
+                this.website_url.TrueEqualsString(obj.website_url);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.about_me.TrueEqualsString((string)obj.about_me) &&
+                this.accept_rate.TrueEquals((int?)obj.accept_rate) &&
+                this.account_id.TrueEquals((int?)obj.account_id) &&
+                this.age.TrueEquals((int?)obj.age) &&
+                this.answer_count.TrueEquals((int?)obj.answer_count) &&
+                ((this.badge_counts == null && obj.badge_counts == null) || this.badge_counts.EqualsDynamic(obj.badge_counts)) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.display_name.TrueEqualsString((string)obj.display_name) &&
+                this.down_vote_count.TrueEquals((int?)obj.down_vote_count) &&
+                this.is_employee.TrueEquals((bool?)obj.is_employee) &&
+                this.last_access_date.TrueEquals((DateTime?)obj.last_access_date) &&
+                this.last_modified_date.TrueEquals((DateTime?)obj.last_modified_date) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.location.TrueEqualsString((string)obj.location) &&
+                this.profile_image.TrueEqualsString((string)obj.profile_image) &&
+                this.question_count.TrueEquals((int?)obj.question_count) &&
+                this.reputation.TrueEquals((int?)obj.reputation) &&
+                this.reputation_change_day.TrueEquals((int?)obj.reputation_change_day) &&
+                this.reputation_change_month.TrueEquals((int?)obj.reputation_change_month) &&
+                this.reputation_change_quarter.TrueEquals((int?)obj.reputation_change_quarter) &&
+                this.reputation_change_week.TrueEquals((int?)obj.reputation_change_week) &&
+                this.reputation_change_year.TrueEquals((int?)obj.reputation_change_year) &&
+                this.timed_penalty_date.TrueEquals((DateTime?)obj.timed_penalty_date) &&
+                this.up_vote_count.TrueEquals((int?)obj.up_vote_count) &&
+                this.user_id.TrueEquals((int?)obj.user_id) &&
+                this.user_type.TrueEquals((UserType?)obj.user_type) &&
+                this.view_count.TrueEquals((int?)obj.view_count) &&
+                this.website_url.TrueEqualsString((string)obj.website_url);
+        }
+
+        [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+        public class BadgeCount : IGenericEquality<BadgeCount>
+        {
+            [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+            public int? gold { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+            public int? silver { get; set; }
+
+            [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+            public int? bronze { get; set; }
+
+            public bool Equals(BadgeCount obj)
+            {
+                return
+                    this.bronze.TrueEquals(obj.bronze) &&
+                    this.silver.TrueEquals(obj.silver) &&
+                    this.gold.TrueEquals(obj.gold);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.bronze.TrueEquals((int?)obj.bronze) &&
+                    this.silver.TrueEquals((int?)obj.silver) &&
+                    this.gold.TrueEquals((int?)obj.gold);
+            }
+        }
+
+        [MessagePack.MessagePackObject(true)]
+        public class BadgeCount2 : IGenericEquality<BadgeCount2>
+        {
+            public int? gold { get; set; }
+            public int? silver { get; set; }
+            public int? bronze { get; set; }
+
+            public bool Equals(BadgeCount2 obj)
+            {
+                return
+                    this.bronze.TrueEquals(obj.bronze) &&
+                    this.silver.TrueEquals(obj.silver) &&
+                    this.gold.TrueEquals(obj.gold);
+            }
+
+            public bool EqualsDynamic(dynamic obj)
+            {
+                return
+                    this.bronze.TrueEquals((int?)obj.bronze) &&
+                    this.silver.TrueEquals((int?)obj.silver) &&
+                    this.gold.TrueEquals((int?)obj.gold);
+            }
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/UserTimeline.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/UserTimeline.cs
new file mode 100644
index 000000000..435f125c7
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/UserTimeline.cs
@@ -0,0 +1,90 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    public enum UserTimelineType : byte
+    {
+        commented = 1,
+        asked = 2,
+        answered = 3,
+        badge = 4,
+        revision = 5,
+        accepted = 6,
+        reviewed = 7,
+        suggested = 8,
+    }
+
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class UserTimeline : IGenericEquality<UserTimeline>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public DateTime? creation_date { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public PostType? post_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public UserTimelineType? timeline_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public int? post_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? comment_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? suggested_edit_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(8), MessagePack.Key(8 - 1)]
+        public int? badge_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(9), MessagePack.Key(9 - 1)]
+        public string title { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(10), MessagePack.Key(10 - 1)]
+        public string detail { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(11), MessagePack.Key(11 - 1)]
+        public string link { get; set; }
+
+        public bool Equals(UserTimeline obj)
+        {
+            return
+                this.badge_id.TrueEquals(obj.badge_id) &&
+                this.comment_id.TrueEquals(obj.comment_id) &&
+                this.creation_date.TrueEquals(obj.creation_date) &&
+                this.detail.TrueEqualsString(obj.detail) &&
+                this.link.TrueEqualsString(obj.link) &&
+                this.post_id.TrueEquals(obj.post_id) &&
+                this.post_type.TrueEquals(obj.post_type) &&
+                this.suggested_edit_id.TrueEquals(obj.suggested_edit_id) &&
+                this.timeline_type.TrueEquals(obj.timeline_type) &&
+                this.title.TrueEqualsString(obj.title) &&
+                this.user_id.TrueEquals(obj.user_id);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.badge_id.TrueEquals((int?)obj.badge_id) &&
+                this.comment_id.TrueEquals((int?)obj.comment_id) &&
+                this.creation_date.TrueEquals((DateTime?)obj.creation_date) &&
+                this.detail.TrueEqualsString((string)obj.detail) &&
+                this.link.TrueEqualsString((string)obj.link) &&
+                this.post_id.TrueEquals((int?)obj.post_id) &&
+                this.post_type.TrueEquals((PostType?)obj.post_type) &&
+                this.suggested_edit_id.TrueEquals((int?)obj.suggested_edit_id) &&
+                this.timeline_type.TrueEquals((UserTimelineType?)obj.timeline_type) &&
+                this.title.TrueEqualsString((string)obj.title) &&
+                this.user_id.TrueEquals((int?)obj.user_id);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Models/WritePermission.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Models/WritePermission.cs
new file mode 100644
index 000000000..61e1af74c
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Models/WritePermission.cs
@@ -0,0 +1,57 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using ProtoBuf;
+
+namespace Benchmark.Models
+{
+    [ProtoContract, System.Serializable, System.Runtime.Serialization.DataContract, MessagePack.MessagePackObject]
+    public class WritePermission : IGenericEquality<WritePermission>
+    {
+        [System.Runtime.Serialization.DataMember, ProtoMember(1), MessagePack.Key(1 - 1)]
+        public int? user_id { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(2), MessagePack.Key(2 - 1)]
+        public string object_type { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(3), MessagePack.Key(3 - 1)]
+        public bool? can_add { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(4), MessagePack.Key(4 - 1)]
+        public bool? can_edit { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(5), MessagePack.Key(5 - 1)]
+        public bool? can_delete { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(6), MessagePack.Key(6 - 1)]
+        public int? max_daily_actions { get; set; }
+
+        [System.Runtime.Serialization.DataMember, ProtoMember(7), MessagePack.Key(7 - 1)]
+        public int? min_seconds_between_actions { get; set; }
+
+        public bool Equals(WritePermission obj)
+        {
+            return
+                this.can_add.TrueEquals(obj.can_add) &&
+                this.can_delete.TrueEquals(obj.can_delete) &&
+                this.can_edit.TrueEquals(obj.can_edit) &&
+                this.max_daily_actions.TrueEquals(obj.max_daily_actions) &&
+                this.min_seconds_between_actions.TrueEquals(obj.min_seconds_between_actions) &&
+                this.object_type.TrueEqualsString(obj.object_type) &&
+                this.user_id.TrueEquals(obj.user_id);
+        }
+
+        public bool EqualsDynamic(dynamic obj)
+        {
+            return
+                this.can_add.TrueEquals((bool?)obj.can_add) &&
+                this.can_delete.TrueEquals((bool?)obj.can_delete) &&
+                this.can_edit.TrueEquals((bool?)obj.can_edit) &&
+                this.max_daily_actions.TrueEquals((int?)obj.max_daily_actions) &&
+                this.min_seconds_between_actions.TrueEquals((int?)obj.min_seconds_between_actions) &&
+                this.object_type.TrueEqualsString((string)obj.object_type) &&
+                this.user_id.TrueEquals((int?)obj.user_id);
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/SerializerBenchmark.cs b/test/Benchmark/MessagePackCsharp/Benchmark/SerializerBenchmark.cs
new file mode 100644
index 000000000..3070e6268
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/SerializerBenchmark.cs
@@ -0,0 +1,1234 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Benchmark.Fixture;
+using Benchmark.Models;
+using Benchmark.Serializers;
+using BenchmarkDotNet.Attributes;
+
+#pragma warning disable SA1300 // Element should begin with upper-case letter
+#pragma warning disable SA1306 // Field names should begin with lower-case letter
+#pragma warning disable SA1401 // Fields should be private
+#pragma warning disable SA1649 // File name should match first type name
+#pragma warning disable IDE004
+#pragma warning disable IDE0049
+
+namespace Benchmark
+{
+    [Config(typeof(BenchmarkConfig))]
+    public class AllSerializerBenchmark_BytesInOut
+    {
+        [ParamsSource(nameof(Serializers))]
+        public SerializerBase Serializer;
+
+        // Currently BenchmarkdDotNet does not detect inherited ParamsSource so use copy and paste:)
+        public IEnumerable<SerializerBase> Serializers => new SerializerBase[]
+        {
+            new MessagePack_v2(),
+            new MessagePackLz4_v2(),
+            new MsgPack_v2_opt(),
+            //new MsgPack_v2_string(),
+            //new MsgPack_v2_str_lz4(),
+            new ProtobufNet(),
+            new JsonNet(),
+            new BinaryFormatter_(),
+            new DataContract_(),
+            new Hyperion_(),
+            new Jil_(),
+            new SpanJson_(),
+            new Utf8Json_(),
+            new SystemTextJson(),
+            new MsgPackCli(),
+			new MsgPackCli_v2(),
+			new FsPickler_(),
+            new Ceras_(),
+        };
+
+        protected static readonly ExpressionTreeFixture ExpressionTreeFixture = new ExpressionTreeFixture();
+
+        // primitives
+        protected static readonly sbyte SByteInput = ExpressionTreeFixture.Create<sbyte>();
+        protected static readonly short ShortInput = ExpressionTreeFixture.Create<short>();
+        protected static readonly int IntInput = ExpressionTreeFixture.Create<int>();
+        protected static readonly long LongInput = ExpressionTreeFixture.Create<long>();
+        protected static readonly byte ByteInput = ExpressionTreeFixture.Create<byte>();
+        protected static readonly ushort UShortInput = ExpressionTreeFixture.Create<ushort>();
+        protected static readonly uint UIntInput = ExpressionTreeFixture.Create<uint>();
+        protected static readonly ulong ULongInput = ExpressionTreeFixture.Create<ulong>();
+        protected static readonly bool BoolInput = ExpressionTreeFixture.Create<bool>();
+        protected static readonly string StringInput = ExpressionTreeFixture.Create<string>();
+        protected static readonly char CharInput = ExpressionTreeFixture.Create<char>();
+        protected static readonly DateTime DateTimeInput = ExpressionTreeFixture.Create<DateTime>();
+        protected static readonly Guid GuidInput = ExpressionTreeFixture.Create<Guid>();
+        protected static readonly byte[] BytesInput = ExpressionTreeFixture.Create<byte[]>();
+
+        // models
+        protected static readonly Benchmark.Models.AccessToken AccessTokenInput = ExpressionTreeFixture.Create<Benchmark.Models.AccessToken>();
+
+        protected static readonly Benchmark.Models.AccountMerge AccountMergeInput = ExpressionTreeFixture.Create<Benchmark.Models.AccountMerge>();
+
+        protected static readonly Benchmark.Models.Answer AnswerInput = ExpressionTreeFixture.Create<Benchmark.Models.Answer>();
+
+        protected static readonly Benchmark.Models.Badge BadgeInput = ExpressionTreeFixture.Create<Benchmark.Models.Badge>();
+
+        protected static readonly Benchmark.Models.Comment CommentInput = ExpressionTreeFixture.Create<Benchmark.Models.Comment>();
+
+        protected static readonly Benchmark.Models.Error ErrorInput = ExpressionTreeFixture.Create<Benchmark.Models.Error>();
+
+        protected static readonly Benchmark.Models.Event EventInput = ExpressionTreeFixture.Create<Benchmark.Models.Event>();
+
+        protected static readonly Benchmark.Models.MobileFeed MobileFeedInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileFeed>();
+
+        protected static readonly Benchmark.Models.MobileQuestion MobileQuestionInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileQuestion>();
+
+        protected static readonly Benchmark.Models.MobileRepChange MobileRepChangeInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileRepChange>();
+
+        protected static readonly Benchmark.Models.MobileInboxItem MobileInboxItemInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileInboxItem>();
+
+        protected static readonly Benchmark.Models.MobileBadgeAward MobileBadgeAwardInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileBadgeAward>();
+
+        protected static readonly Benchmark.Models.MobilePrivilege MobilePrivilegeInput = ExpressionTreeFixture.Create<Benchmark.Models.MobilePrivilege>();
+
+        protected static readonly Benchmark.Models.MobileCommunityBulletin MobileCommunityBulletinInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileCommunityBulletin>();
+
+        protected static readonly Benchmark.Models.MobileAssociationBonus MobileAssociationBonusInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileAssociationBonus>();
+
+        protected static readonly Benchmark.Models.MobileCareersJobAd MobileCareersJobAdInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileCareersJobAd>();
+
+        protected static readonly Benchmark.Models.MobileBannerAd MobileBannerAdInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileBannerAd>();
+
+        protected static readonly Benchmark.Models.MobileUpdateNotice MobileUpdateNoticeInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileUpdateNotice>();
+
+        protected static readonly Benchmark.Models.FlagOption FlagOptionInput = ExpressionTreeFixture.Create<Benchmark.Models.FlagOption>();
+
+        protected static readonly Benchmark.Models.InboxItem InboxItemInput = ExpressionTreeFixture.Create<Benchmark.Models.InboxItem>();
+
+        protected static readonly Benchmark.Models.Info InfoInput = ExpressionTreeFixture.Create<Benchmark.Models.Info>();
+
+        protected static readonly Benchmark.Models.NetworkUser NetworkUserInput = ExpressionTreeFixture.Create<Benchmark.Models.NetworkUser>();
+
+        protected static readonly Benchmark.Models.Notification NotificationInput = ExpressionTreeFixture.Create<Benchmark.Models.Notification>();
+
+        protected static readonly Benchmark.Models.Post PostInput = ExpressionTreeFixture.Create<Benchmark.Models.Post>();
+
+        protected static readonly Benchmark.Models.Privilege PrivilegeInput = ExpressionTreeFixture.Create<Benchmark.Models.Privilege>();
+
+        protected static readonly Benchmark.Models.Question QuestionInput = ExpressionTreeFixture.Create<Benchmark.Models.Question>();
+
+        protected static readonly Benchmark.Models.QuestionTimeline QuestionTimelineInput = ExpressionTreeFixture.Create<Benchmark.Models.QuestionTimeline>();
+
+        protected static readonly Benchmark.Models.Reputation ReputationInput = ExpressionTreeFixture.Create<Benchmark.Models.Reputation>();
+
+        protected static readonly Benchmark.Models.ReputationHistory ReputationHistoryInput = ExpressionTreeFixture.Create<Benchmark.Models.ReputationHistory>();
+
+        protected static readonly Benchmark.Models.Revision RevisionInput = ExpressionTreeFixture.Create<Benchmark.Models.Revision>();
+
+        protected static readonly Benchmark.Models.SearchExcerpt SearchExcerptInput = ExpressionTreeFixture.Create<Benchmark.Models.SearchExcerpt>();
+
+        protected static readonly Benchmark.Models.ShallowUser ShallowUserInput = ExpressionTreeFixture.Create<Benchmark.Models.ShallowUser>();
+
+        protected static readonly Benchmark.Models.SuggestedEdit SuggestedEditInput = ExpressionTreeFixture.Create<Benchmark.Models.SuggestedEdit>();
+
+        protected static readonly Benchmark.Models.Tag TagInput = ExpressionTreeFixture.Create<Benchmark.Models.Tag>();
+
+        protected static readonly Benchmark.Models.TagScore TagScoreInput = ExpressionTreeFixture.Create<Benchmark.Models.TagScore>();
+
+        protected static readonly Benchmark.Models.TagSynonym TagSynonymInput = ExpressionTreeFixture.Create<Benchmark.Models.TagSynonym>();
+
+        protected static readonly Benchmark.Models.TagWiki TagWikiInput = ExpressionTreeFixture.Create<Benchmark.Models.TagWiki>();
+
+        protected static readonly Benchmark.Models.TopTag TopTagInput = ExpressionTreeFixture.Create<Benchmark.Models.TopTag>();
+
+        protected static readonly Benchmark.Models.User UserInput = ExpressionTreeFixture.Create<Benchmark.Models.User>();
+
+        protected static readonly Benchmark.Models.UserTimeline UserTimelineInput = ExpressionTreeFixture.Create<Benchmark.Models.UserTimeline>();
+
+        protected static readonly Benchmark.Models.WritePermission WritePermissionInput = ExpressionTreeFixture.Create<Benchmark.Models.WritePermission>();
+
+        protected static readonly Benchmark.Models.MobileBannerAd.MobileBannerAdImage MobileBannerAdImageInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileBannerAd.MobileBannerAdImage>();
+
+        protected static readonly Benchmark.Models.Info.Site SiteInput = ExpressionTreeFixture.Create<Benchmark.Models.Info.Site>();
+
+        protected static readonly Benchmark.Models.Info.RelatedSite RelatedSiteInput = ExpressionTreeFixture.Create<Benchmark.Models.Info.RelatedSite>();
+
+        protected static readonly Benchmark.Models.Question.ClosedDetails ClosedDetailsInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.ClosedDetails>();
+
+        protected static readonly Benchmark.Models.Question.Notice NoticeInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.Notice>();
+
+        protected static readonly Benchmark.Models.Question.MigrationInfo MigrationInfoInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.MigrationInfo>();
+
+        protected static readonly Benchmark.Models.User.BadgeCount BadgeCountInput = ExpressionTreeFixture.Create<Benchmark.Models.User.BadgeCount>();
+
+        protected static readonly Benchmark.Models.Info.Site.Styling StylingInput = ExpressionTreeFixture.Create<Benchmark.Models.Info.Site.Styling>();
+
+        protected static readonly Benchmark.Models.Question.ClosedDetails.OriginalQuestion OriginalQuestionInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.ClosedDetails.OriginalQuestion>();
+
+        private object SByteOutput;
+        private object ShortOutput;
+        private object IntOutput;
+        private object LongOutput;
+        private object ByteOutput;
+        private object UShortOutput;
+        private object UIntOutput;
+        private object ULongOutput;
+        private object BoolOutput;
+        private object StringOutput;
+        private object CharOutput;
+        private object DateTimeOutput;
+        private object GuidOutput;
+        private object BytesOutput;
+
+        private object AccessTokenOutput;
+        private object AccountMergeOutput;
+        private object AnswerOutput;
+        private object BadgeOutput;
+        private object CommentOutput;
+        private object ErrorOutput;
+        private object EventOutput;
+        private object MobileFeedOutput;
+        private object MobileQuestionOutput;
+        private object MobileRepChangeOutput;
+        private object MobileInboxItemOutput;
+        private object MobileBadgeAwardOutput;
+        private object MobilePrivilegeOutput;
+        private object MobileCommunityBulletinOutput;
+        private object MobileAssociationBonusOutput;
+        private object MobileCareersJobAdOutput;
+        private object MobileBannerAdOutput;
+        private object MobileUpdateNoticeOutput;
+        private object FlagOptionOutput;
+        private object InboxItemOutput;
+        private object InfoOutput;
+        private object NetworkUserOutput;
+        private object NotificationOutput;
+        private object PostOutput;
+        private object PrivilegeOutput;
+        private object QuestionOutput;
+        private object QuestionTimelineOutput;
+        private object ReputationOutput;
+        private object ReputationHistoryOutput;
+        private object RevisionOutput;
+        private object SearchExcerptOutput;
+        private object ShallowUserOutput;
+        private object SuggestedEditOutput;
+        private object TagOutput;
+        private object TagScoreOutput;
+        private object TagSynonymOutput;
+        private object TagWikiOutput;
+        private object TopTagOutput;
+        private object UserOutput;
+        private object UserTimelineOutput;
+        private object WritePermissionOutput;
+        private object MobileBannerAdImageOutput;
+        private object SiteOutput;
+        private object RelatedSiteOutput;
+        private object ClosedDetailsOutput;
+        private object NoticeOutput;
+        private object MigrationInfoOutput;
+        private object BadgeCountOutput;
+        private object StylingOutput;
+        private object OriginalQuestionOutput;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            // primitives
+            this.SByteOutput = this.Serializer.Serialize(SByteInput);
+            this.ShortOutput = this.Serializer.Serialize(ShortInput);
+            this.IntOutput = this.Serializer.Serialize(IntInput);
+            this.LongOutput = this.Serializer.Serialize(LongInput);
+            this.ByteOutput = this.Serializer.Serialize(ByteInput);
+            this.UShortOutput = this.Serializer.Serialize(UShortInput);
+            this.UIntOutput = this.Serializer.Serialize(UIntInput);
+            this.ULongOutput = this.Serializer.Serialize(ULongInput);
+            this.BoolOutput = this.Serializer.Serialize(BoolInput);
+            this.StringOutput = this.Serializer.Serialize(StringInput);
+            this.CharOutput = this.Serializer.Serialize(CharInput);
+            this.DateTimeOutput = this.Serializer.Serialize(DateTimeInput);
+            this.GuidOutput = this.Serializer.Serialize(GuidInput);
+            this.BytesOutput = this.Serializer.Serialize(BytesInput);
+
+            // models
+            this.AccessTokenOutput = this.Serializer.Serialize(AccessTokenInput);
+            this.AccountMergeOutput = this.Serializer.Serialize(AccountMergeInput);
+            this.AnswerOutput = this.Serializer.Serialize(AnswerInput);
+            this.BadgeOutput = this.Serializer.Serialize(BadgeInput);
+            this.CommentOutput = this.Serializer.Serialize(CommentInput);
+            this.ErrorOutput = this.Serializer.Serialize(ErrorInput);
+            this.EventOutput = this.Serializer.Serialize(EventInput);
+            this.MobileFeedOutput = this.Serializer.Serialize(MobileFeedInput);
+            this.MobileQuestionOutput = this.Serializer.Serialize(MobileQuestionInput);
+            this.MobileRepChangeOutput = this.Serializer.Serialize(MobileRepChangeInput);
+            this.MobileInboxItemOutput = this.Serializer.Serialize(MobileInboxItemInput);
+            this.MobileBadgeAwardOutput = this.Serializer.Serialize(MobileBadgeAwardInput);
+            this.MobilePrivilegeOutput = this.Serializer.Serialize(MobilePrivilegeInput);
+            this.MobileCommunityBulletinOutput = this.Serializer.Serialize(MobileCommunityBulletinInput);
+            this.MobileAssociationBonusOutput = this.Serializer.Serialize(MobileAssociationBonusInput);
+            this.MobileCareersJobAdOutput = this.Serializer.Serialize(MobileCareersJobAdInput);
+            this.MobileBannerAdOutput = this.Serializer.Serialize(MobileBannerAdInput);
+            this.MobileUpdateNoticeOutput = this.Serializer.Serialize(MobileUpdateNoticeInput);
+            this.FlagOptionOutput = this.Serializer.Serialize(FlagOptionInput);
+            this.InboxItemOutput = this.Serializer.Serialize(InboxItemInput);
+            this.InfoOutput = this.Serializer.Serialize(InfoInput);
+            this.NetworkUserOutput = this.Serializer.Serialize(NetworkUserInput);
+            this.NotificationOutput = this.Serializer.Serialize(NotificationInput);
+            this.PostOutput = this.Serializer.Serialize(PostInput);
+            this.PrivilegeOutput = this.Serializer.Serialize(PrivilegeInput);
+            this.QuestionOutput = this.Serializer.Serialize(QuestionInput);
+            this.QuestionTimelineOutput = this.Serializer.Serialize(QuestionTimelineInput);
+            this.ReputationOutput = this.Serializer.Serialize(ReputationInput);
+            this.ReputationHistoryOutput = this.Serializer.Serialize(ReputationHistoryInput);
+            this.RevisionOutput = this.Serializer.Serialize(RevisionInput);
+            this.SearchExcerptOutput = this.Serializer.Serialize(SearchExcerptInput);
+            this.ShallowUserOutput = this.Serializer.Serialize(ShallowUserInput);
+            this.SuggestedEditOutput = this.Serializer.Serialize(SuggestedEditInput);
+            this.TagOutput = this.Serializer.Serialize(TagInput);
+            this.TagScoreOutput = this.Serializer.Serialize(TagScoreInput);
+            this.TagSynonymOutput = this.Serializer.Serialize(TagSynonymInput);
+            this.TagWikiOutput = this.Serializer.Serialize(TagWikiInput);
+            this.TopTagOutput = this.Serializer.Serialize(TopTagInput);
+            this.UserOutput = this.Serializer.Serialize(UserInput);
+            this.UserTimelineOutput = this.Serializer.Serialize(UserTimelineInput);
+            this.WritePermissionOutput = this.Serializer.Serialize(WritePermissionInput);
+            this.MobileBannerAdImageOutput = this.Serializer.Serialize(MobileBannerAdImageInput);
+            this.SiteOutput = this.Serializer.Serialize(SiteInput);
+            this.RelatedSiteOutput = this.Serializer.Serialize(RelatedSiteInput);
+            this.ClosedDetailsOutput = this.Serializer.Serialize(ClosedDetailsInput);
+            this.NoticeOutput = this.Serializer.Serialize(NoticeInput);
+            this.MigrationInfoOutput = this.Serializer.Serialize(MigrationInfoInput);
+            this.BadgeCountOutput = this.Serializer.Serialize(BadgeCountInput);
+            this.StylingOutput = this.Serializer.Serialize(StylingInput);
+            this.OriginalQuestionOutput = this.Serializer.Serialize(OriginalQuestionInput);
+        }
+
+        // Serialize
+        [Benchmark] public object _PrimitiveSByteSerialize() => this.Serializer.Serialize(SByteInput);
+
+        [Benchmark] public object _PrimitiveShortSerialize() => this.Serializer.Serialize(ShortInput);
+
+        [Benchmark] public object _PrimitiveIntSerialize() => this.Serializer.Serialize(IntInput);
+
+        [Benchmark] public object _PrimitiveLongSerialize() => this.Serializer.Serialize(LongInput);
+
+        [Benchmark] public object _PrimitiveByteSerialize() => this.Serializer.Serialize(ByteInput);
+
+        [Benchmark] public object _PrimitiveUShortSerialize() => this.Serializer.Serialize(UShortInput);
+
+        [Benchmark] public object _PrimitiveUIntSerialize() => this.Serializer.Serialize(UIntInput);
+
+        [Benchmark] public object _PrimitiveULongSerialize() => this.Serializer.Serialize(ULongInput);
+
+        [Benchmark] public object _PrimitiveBoolSerialize() => this.Serializer.Serialize(BoolInput);
+
+        [Benchmark] public object _PrimitiveStringSerialize() => this.Serializer.Serialize(StringInput);
+
+        [Benchmark] public object _PrimitiveCharSerialize() => this.Serializer.Serialize(CharInput);
+
+        [Benchmark] public object _PrimitiveDateTimeSerialize() => this.Serializer.Serialize(DateTimeInput);
+
+        [Benchmark] public object _PrimitiveGuidSerialize() => this.Serializer.Serialize(GuidInput);
+
+        [Benchmark] public object _PrimitiveBytesSerialize() => this.Serializer.Serialize(BytesInput);
+
+        [Benchmark] public object AccessTokenSerialize() => this.Serializer.Serialize(AccessTokenInput);
+
+        [Benchmark] public object AccountMergeSerialize() => this.Serializer.Serialize(AccountMergeInput);
+
+        [Benchmark] public object AnswerSerialize() => this.Serializer.Serialize(AnswerInput);
+
+        [Benchmark] public object BadgeSerialize() => this.Serializer.Serialize(BadgeInput);
+
+        [Benchmark] public object CommentSerialize() => this.Serializer.Serialize(CommentInput);
+
+        [Benchmark] public object ErrorSerialize() => this.Serializer.Serialize(ErrorInput);
+
+        [Benchmark] public object EventSerialize() => this.Serializer.Serialize(EventInput);
+
+        [Benchmark] public object MobileFeedSerialize() => this.Serializer.Serialize(MobileFeedInput);
+
+        [Benchmark] public object MobileQuestionSerialize() => this.Serializer.Serialize(MobileQuestionInput);
+
+        [Benchmark] public object MobileRepChangeSerialize() => this.Serializer.Serialize(MobileRepChangeInput);
+
+        [Benchmark] public object MobileInboxItemSerialize() => this.Serializer.Serialize(MobileInboxItemInput);
+
+        [Benchmark] public object MobileBadgeAwardSerialize() => this.Serializer.Serialize(MobileBadgeAwardInput);
+
+        [Benchmark] public object MobilePrivilegeSerialize() => this.Serializer.Serialize(MobilePrivilegeInput);
+
+        [Benchmark] public object MobileCommunityBulletinSerialize() => this.Serializer.Serialize(MobileCommunityBulletinInput);
+
+        [Benchmark] public object MobileAssociationBonusSerialize() => this.Serializer.Serialize(MobileAssociationBonusInput);
+
+        [Benchmark] public object MobileCareersJobAdSerialize() => this.Serializer.Serialize(MobileCareersJobAdInput);
+
+        [Benchmark] public object MobileBannerAdSerialize() => this.Serializer.Serialize(MobileBannerAdInput);
+
+        [Benchmark] public object MobileUpdateNoticeSerialize() => this.Serializer.Serialize(MobileUpdateNoticeInput);
+
+        [Benchmark] public object FlagOptionSerialize() => this.Serializer.Serialize(FlagOptionInput);
+
+        [Benchmark] public object InboxItemSerialize() => this.Serializer.Serialize(InboxItemInput);
+
+        [Benchmark] public object InfoSerialize() => this.Serializer.Serialize(InfoInput);
+
+        [Benchmark] public object NetworkUserSerialize() => this.Serializer.Serialize(NetworkUserInput);
+
+        [Benchmark] public object NotificationSerialize() => this.Serializer.Serialize(NotificationInput);
+
+        [Benchmark] public object PostSerialize() => this.Serializer.Serialize(PostInput);
+
+        [Benchmark] public object PrivilegeSerialize() => this.Serializer.Serialize(PrivilegeInput);
+
+        [Benchmark] public object QuestionSerialize() => this.Serializer.Serialize(QuestionInput);
+
+        [Benchmark] public object QuestionTimelineSerialize() => this.Serializer.Serialize(QuestionTimelineInput);
+
+        [Benchmark] public object ReputationSerialize() => this.Serializer.Serialize(ReputationInput);
+
+        [Benchmark] public object ReputationHistorySerialize() => this.Serializer.Serialize(ReputationHistoryInput);
+
+        [Benchmark] public object RevisionSerialize() => this.Serializer.Serialize(RevisionInput);
+
+        [Benchmark] public object SearchExcerptSerialize() => this.Serializer.Serialize(SearchExcerptInput);
+
+        [Benchmark] public object ShallowUserSerialize() => this.Serializer.Serialize(ShallowUserInput);
+
+        [Benchmark] public object SuggestedEditSerialize() => this.Serializer.Serialize(SuggestedEditInput);
+
+        [Benchmark] public object TagSerialize() => this.Serializer.Serialize(TagInput);
+
+        [Benchmark] public object TagScoreSerialize() => this.Serializer.Serialize(TagScoreInput);
+
+        [Benchmark] public object TagSynonymSerialize() => this.Serializer.Serialize(TagSynonymInput);
+
+        [Benchmark] public object TagWikiSerialize() => this.Serializer.Serialize(TagWikiInput);
+
+        [Benchmark] public object TopTagSerialize() => this.Serializer.Serialize(TopTagInput);
+
+        [Benchmark] public object UserSerialize() => this.Serializer.Serialize(UserInput);
+
+        [Benchmark] public object UserTimelineSerialize() => this.Serializer.Serialize(UserTimelineInput);
+
+        [Benchmark] public object WritePermissionSerialize() => this.Serializer.Serialize(WritePermissionInput);
+
+        [Benchmark] public object MobileBannerAdImageSerialize() => this.Serializer.Serialize(MobileBannerAdImageInput);
+
+        [Benchmark] public object SiteSerialize() => this.Serializer.Serialize(SiteInput);
+
+        [Benchmark] public object RelatedSiteSerialize() => this.Serializer.Serialize(RelatedSiteInput);
+
+        [Benchmark] public object ClosedDetailsSerialize() => this.Serializer.Serialize(ClosedDetailsInput);
+
+        [Benchmark] public object NoticeSerialize() => this.Serializer.Serialize(NoticeInput);
+
+        [Benchmark] public object MigrationInfoSerialize() => this.Serializer.Serialize(MigrationInfoInput);
+
+        [Benchmark] public object BadgeCountSerialize() => this.Serializer.Serialize(BadgeCountInput);
+
+        [Benchmark] public object StylingSerialize() => this.Serializer.Serialize(StylingInput);
+
+        [Benchmark] public object OriginalQuestionSerialize() => this.Serializer.Serialize(OriginalQuestionInput);
+
+        // Deserialize
+        [Benchmark] public SByte _PrimitiveSByteDeserialize() => this.Serializer.Deserialize<SByte>(this.SByteOutput);
+
+        [Benchmark] public short _PrimitiveShortDeserialize() => this.Serializer.Deserialize<short>(this.ShortOutput);
+
+        [Benchmark] public Int32 _PrimitiveIntDeserialize() => this.Serializer.Deserialize<Int32>(this.IntOutput);
+
+        [Benchmark] public Int64 _PrimitiveLongDeserialize() => this.Serializer.Deserialize<Int64>(this.LongOutput);
+
+        [Benchmark] public Byte _PrimitiveByteDeserialize() => this.Serializer.Deserialize<Byte>(this.ByteOutput);
+
+        [Benchmark] public ushort _PrimitiveUShortDeserialize() => this.Serializer.Deserialize<ushort>(this.UShortOutput);
+
+        [Benchmark] public uint _PrimitiveUIntDeserialize() => this.Serializer.Deserialize<uint>(this.UIntOutput);
+
+        [Benchmark] public ulong _PrimitiveULongDeserialize() => this.Serializer.Deserialize<ulong>(this.ULongOutput);
+
+        [Benchmark] public bool _PrimitiveBoolDeserialize() => this.Serializer.Deserialize<bool>(this.BoolOutput);
+
+        [Benchmark] public String _PrimitiveStringDeserialize() => this.Serializer.Deserialize<String>(this.StringOutput);
+
+        [Benchmark] public Char _PrimitiveCharDeserialize() => this.Serializer.Deserialize<Char>(this.CharOutput);
+
+        [Benchmark] public DateTime _PrimitiveDateTimeDeserialize() => this.Serializer.Deserialize<DateTime>(this.DateTimeOutput);
+
+        [Benchmark] public Guid _PrimitiveGuidDeserialize() => this.Serializer.Deserialize<Guid>(this.GuidOutput);
+
+        [Benchmark] public byte[] _PrimitiveBytesDeserialize() => this.Serializer.Deserialize<byte[]>(this.BytesOutput);
+
+        [Benchmark] public AccessToken AccessTokenDeserialize() => this.Serializer.Deserialize<AccessToken>(this.AccessTokenOutput);
+
+        [Benchmark] public AccountMerge AccountMergeDeserialize() => this.Serializer.Deserialize<AccountMerge>(this.AccountMergeOutput);
+
+        [Benchmark] public Answer AnswerDeserialize() => this.Serializer.Deserialize<Answer>(this.AnswerOutput);
+
+        [Benchmark] public Badge BadgeDeserialize() => this.Serializer.Deserialize<Badge>(this.BadgeOutput);
+
+        [Benchmark] public Comment CommentDeserialize() => this.Serializer.Deserialize<Comment>(this.CommentOutput);
+
+        [Benchmark] public Error ErrorDeserialize() => this.Serializer.Deserialize<Error>(this.ErrorOutput);
+
+        [Benchmark] public Event EventDeserialize() => this.Serializer.Deserialize<Event>(this.EventOutput);
+
+        [Benchmark] public MobileFeed MobileFeedDeserialize() => this.Serializer.Deserialize<MobileFeed>(this.MobileFeedOutput);
+
+        [Benchmark] public MobileQuestion MobileQuestionDeserialize() => this.Serializer.Deserialize<MobileQuestion>(this.MobileQuestionOutput);
+
+        [Benchmark] public MobileRepChange MobileRepChangeDeserialize() => this.Serializer.Deserialize<MobileRepChange>(this.MobileRepChangeOutput);
+
+        [Benchmark] public MobileInboxItem MobileInboxItemDeserialize() => this.Serializer.Deserialize<MobileInboxItem>(this.MobileInboxItemOutput);
+
+        [Benchmark] public MobileBadgeAward MobileBadgeAwardDeserialize() => this.Serializer.Deserialize<MobileBadgeAward>(this.MobileBadgeAwardOutput);
+
+        [Benchmark] public MobilePrivilege MobilePrivilegeDeserialize() => this.Serializer.Deserialize<MobilePrivilege>(this.MobilePrivilegeOutput);
+
+        [Benchmark] public MobileCommunityBulletin MobileCommunityBulletinDeserialize() => this.Serializer.Deserialize<MobileCommunityBulletin>(this.MobileCommunityBulletinOutput);
+
+        [Benchmark] public MobileAssociationBonus MobileAssociationBonusDeserialize() => this.Serializer.Deserialize<MobileAssociationBonus>(this.MobileAssociationBonusOutput);
+
+        [Benchmark] public MobileCareersJobAd MobileCareersJobAdDeserialize() => this.Serializer.Deserialize<MobileCareersJobAd>(this.MobileCareersJobAdOutput);
+
+        [Benchmark] public MobileBannerAd MobileBannerAdDeserialize() => this.Serializer.Deserialize<MobileBannerAd>(this.MobileBannerAdOutput);
+
+        [Benchmark] public MobileUpdateNotice MobileUpdateNoticeDeserialize() => this.Serializer.Deserialize<MobileUpdateNotice>(this.MobileUpdateNoticeOutput);
+
+        [Benchmark] public FlagOption FlagOptionDeserialize() => this.Serializer.Deserialize<FlagOption>(this.FlagOptionOutput);
+
+        [Benchmark] public InboxItem InboxItemDeserialize() => this.Serializer.Deserialize<InboxItem>(this.InboxItemOutput);
+
+        [Benchmark] public Info InfoDeserialize() => this.Serializer.Deserialize<Info>(this.InfoOutput);
+
+        [Benchmark] public NetworkUser NetworkUserDeserialize() => this.Serializer.Deserialize<NetworkUser>(this.NetworkUserOutput);
+
+        [Benchmark] public Notification NotificationDeserialize() => this.Serializer.Deserialize<Notification>(this.NotificationOutput);
+
+        [Benchmark] public Post PostDeserialize() => this.Serializer.Deserialize<Post>(this.PostOutput);
+
+        [Benchmark] public Privilege PrivilegeDeserialize() => this.Serializer.Deserialize<Privilege>(this.PrivilegeOutput);
+
+        [Benchmark] public Question QuestionDeserialize() => this.Serializer.Deserialize<Question>(this.QuestionOutput);
+
+        [Benchmark] public QuestionTimeline QuestionTimelineDeserialize() => this.Serializer.Deserialize<QuestionTimeline>(this.QuestionTimelineOutput);
+
+        [Benchmark] public Reputation ReputationDeserialize() => this.Serializer.Deserialize<Reputation>(this.ReputationOutput);
+
+        [Benchmark] public ReputationHistory ReputationHistoryDeserialize() => this.Serializer.Deserialize<ReputationHistory>(this.ReputationHistoryOutput);
+
+        [Benchmark] public Revision RevisionDeserialize() => this.Serializer.Deserialize<Revision>(this.RevisionOutput);
+
+        [Benchmark] public SearchExcerpt SearchExcerptDeserialize() => this.Serializer.Deserialize<SearchExcerpt>(this.SearchExcerptOutput);
+
+        [Benchmark] public ShallowUser ShallowUserDeserialize() => this.Serializer.Deserialize<ShallowUser>(this.ShallowUserOutput);
+
+        [Benchmark] public SuggestedEdit SuggestedEditDeserialize() => this.Serializer.Deserialize<SuggestedEdit>(this.SuggestedEditOutput);
+
+        [Benchmark] public Tag TagDeserialize() => this.Serializer.Deserialize<Tag>(this.TagOutput);
+
+        [Benchmark] public TagScore TagScoreDeserialize() => this.Serializer.Deserialize<TagScore>(this.TagScoreOutput);
+
+        [Benchmark] public TagSynonym TagSynonymDeserialize() => this.Serializer.Deserialize<TagSynonym>(this.TagSynonymOutput);
+
+        [Benchmark] public TagWiki TagWikiDeserialize() => this.Serializer.Deserialize<TagWiki>(this.TagWikiOutput);
+
+        [Benchmark] public TopTag TopTagDeserialize() => this.Serializer.Deserialize<TopTag>(this.TopTagOutput);
+
+        [Benchmark] public User UserDeserialize() => this.Serializer.Deserialize<User>(this.UserOutput);
+
+        [Benchmark] public UserTimeline UserTimelineDeserialize() => this.Serializer.Deserialize<UserTimeline>(this.UserTimelineOutput);
+
+        [Benchmark] public WritePermission WritePermissionDeserialize() => this.Serializer.Deserialize<WritePermission>(this.WritePermissionOutput);
+
+        [Benchmark] public MobileBannerAd.MobileBannerAdImage MobileBannerAdImageDeserialize() => this.Serializer.Deserialize<MobileBannerAd.MobileBannerAdImage>(this.MobileBannerAdImageOutput);
+
+        [Benchmark] public Info.Site SiteDeserialize() => this.Serializer.Deserialize<Info.Site>(this.SiteOutput);
+
+        [Benchmark] public Info.RelatedSite RelatedSiteDeserialize() => this.Serializer.Deserialize<Info.RelatedSite>(this.RelatedSiteOutput);
+
+        [Benchmark] public Question.ClosedDetails ClosedDetailsDeserialize() => this.Serializer.Deserialize<Question.ClosedDetails>(this.ClosedDetailsOutput);
+
+        [Benchmark] public Question.Notice NoticeDeserialize() => this.Serializer.Deserialize<Question.Notice>(this.NoticeOutput);
+
+        [Benchmark] public Question.MigrationInfo MigrationInfoDeserialize() => this.Serializer.Deserialize<Question.MigrationInfo>(this.MigrationInfoOutput);
+
+        [Benchmark] public User.BadgeCount BadgeCountDeserialize() => this.Serializer.Deserialize<User.BadgeCount>(this.BadgeCountOutput);
+
+        [Benchmark] public Info.Site.Styling StylingDeserialize() => this.Serializer.Deserialize<Info.Site.Styling>(this.StylingOutput);
+
+        [Benchmark] public Question.ClosedDetails.OriginalQuestion OriginalQuestionDeserialize() => this.Serializer.Deserialize<Question.ClosedDetails.OriginalQuestion>(this.OriginalQuestionOutput);
+    }
+
+    [Config(typeof(BenchmarkConfig))]
+    public class MsgPackV1_Vs_MsgPackV2_BytesInOut // : AllSerializerBenchmark
+    {
+        [ParamsSource(nameof(Serializers))]
+        public SerializerBase Serializer;
+
+        // Currently BenchmarkdDotNet does not detect inherited ParamsSource so use copy and paste:)
+        public IEnumerable<SerializerBase> Serializers => new SerializerBase[]
+        {
+			new MsgPackCli(),
+			new MsgPackCli_v2(),
+        };
+
+        protected static readonly ExpressionTreeFixture ExpressionTreeFixture = new ExpressionTreeFixture();
+
+        // primitives
+        protected static readonly sbyte SByteInput = ExpressionTreeFixture.Create<sbyte>();
+        protected static readonly short ShortInput = ExpressionTreeFixture.Create<short>();
+        protected static readonly int IntInput = ExpressionTreeFixture.Create<int>();
+        protected static readonly long LongInput = ExpressionTreeFixture.Create<long>();
+        protected static readonly byte ByteInput = ExpressionTreeFixture.Create<byte>();
+        protected static readonly ushort UShortInput = ExpressionTreeFixture.Create<ushort>();
+        protected static readonly uint UIntInput = ExpressionTreeFixture.Create<uint>();
+        protected static readonly ulong ULongInput = ExpressionTreeFixture.Create<ulong>();
+        protected static readonly bool BoolInput = ExpressionTreeFixture.Create<bool>();
+        protected static readonly string StringInput = ExpressionTreeFixture.Create<string>();
+        protected static readonly char CharInput = ExpressionTreeFixture.Create<char>();
+        protected static readonly DateTime DateTimeInput = ExpressionTreeFixture.Create<DateTime>();
+        protected static readonly Guid GuidInput = ExpressionTreeFixture.Create<Guid>();
+        protected static readonly byte[] BytesInput = ExpressionTreeFixture.Create<byte[]>();
+
+        // models
+        protected static readonly Benchmark.Models.AccessToken AccessTokenInput = ExpressionTreeFixture.Create<Benchmark.Models.AccessToken>();
+
+        protected static readonly Benchmark.Models.AccountMerge AccountMergeInput = ExpressionTreeFixture.Create<Benchmark.Models.AccountMerge>();
+
+        protected static readonly Benchmark.Models.Answer AnswerInput = ExpressionTreeFixture.Create<Benchmark.Models.Answer>();
+
+        protected static readonly Benchmark.Models.Badge BadgeInput = ExpressionTreeFixture.Create<Benchmark.Models.Badge>();
+
+        protected static readonly Benchmark.Models.Comment CommentInput = ExpressionTreeFixture.Create<Benchmark.Models.Comment>();
+
+        protected static readonly Benchmark.Models.Error ErrorInput = ExpressionTreeFixture.Create<Benchmark.Models.Error>();
+
+        protected static readonly Benchmark.Models.Event EventInput = ExpressionTreeFixture.Create<Benchmark.Models.Event>();
+
+        protected static readonly Benchmark.Models.MobileFeed MobileFeedInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileFeed>();
+
+        protected static readonly Benchmark.Models.MobileQuestion MobileQuestionInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileQuestion>();
+
+        protected static readonly Benchmark.Models.MobileRepChange MobileRepChangeInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileRepChange>();
+
+        protected static readonly Benchmark.Models.MobileInboxItem MobileInboxItemInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileInboxItem>();
+
+        protected static readonly Benchmark.Models.MobileBadgeAward MobileBadgeAwardInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileBadgeAward>();
+
+        protected static readonly Benchmark.Models.MobilePrivilege MobilePrivilegeInput = ExpressionTreeFixture.Create<Benchmark.Models.MobilePrivilege>();
+
+        protected static readonly Benchmark.Models.MobileCommunityBulletin MobileCommunityBulletinInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileCommunityBulletin>();
+
+        protected static readonly Benchmark.Models.MobileAssociationBonus MobileAssociationBonusInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileAssociationBonus>();
+
+        protected static readonly Benchmark.Models.MobileCareersJobAd MobileCareersJobAdInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileCareersJobAd>();
+
+        protected static readonly Benchmark.Models.MobileBannerAd MobileBannerAdInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileBannerAd>();
+
+        protected static readonly Benchmark.Models.MobileUpdateNotice MobileUpdateNoticeInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileUpdateNotice>();
+
+        protected static readonly Benchmark.Models.FlagOption FlagOptionInput = ExpressionTreeFixture.Create<Benchmark.Models.FlagOption>();
+
+        protected static readonly Benchmark.Models.InboxItem InboxItemInput = ExpressionTreeFixture.Create<Benchmark.Models.InboxItem>();
+
+        protected static readonly Benchmark.Models.Info InfoInput = ExpressionTreeFixture.Create<Benchmark.Models.Info>();
+
+        protected static readonly Benchmark.Models.NetworkUser NetworkUserInput = ExpressionTreeFixture.Create<Benchmark.Models.NetworkUser>();
+
+        protected static readonly Benchmark.Models.Notification NotificationInput = ExpressionTreeFixture.Create<Benchmark.Models.Notification>();
+
+        protected static readonly Benchmark.Models.Post PostInput = ExpressionTreeFixture.Create<Benchmark.Models.Post>();
+
+        protected static readonly Benchmark.Models.Privilege PrivilegeInput = ExpressionTreeFixture.Create<Benchmark.Models.Privilege>();
+
+        protected static readonly Benchmark.Models.Question QuestionInput = ExpressionTreeFixture.Create<Benchmark.Models.Question>();
+
+        protected static readonly Benchmark.Models.QuestionTimeline QuestionTimelineInput = ExpressionTreeFixture.Create<Benchmark.Models.QuestionTimeline>();
+
+        protected static readonly Benchmark.Models.Reputation ReputationInput = ExpressionTreeFixture.Create<Benchmark.Models.Reputation>();
+
+        protected static readonly Benchmark.Models.ReputationHistory ReputationHistoryInput = ExpressionTreeFixture.Create<Benchmark.Models.ReputationHistory>();
+
+        protected static readonly Benchmark.Models.Revision RevisionInput = ExpressionTreeFixture.Create<Benchmark.Models.Revision>();
+
+        protected static readonly Benchmark.Models.SearchExcerpt SearchExcerptInput = ExpressionTreeFixture.Create<Benchmark.Models.SearchExcerpt>();
+
+        protected static readonly Benchmark.Models.ShallowUser ShallowUserInput = ExpressionTreeFixture.Create<Benchmark.Models.ShallowUser>();
+
+        protected static readonly Benchmark.Models.SuggestedEdit SuggestedEditInput = ExpressionTreeFixture.Create<Benchmark.Models.SuggestedEdit>();
+
+        protected static readonly Benchmark.Models.Tag TagInput = ExpressionTreeFixture.Create<Benchmark.Models.Tag>();
+
+        protected static readonly Benchmark.Models.TagScore TagScoreInput = ExpressionTreeFixture.Create<Benchmark.Models.TagScore>();
+
+        protected static readonly Benchmark.Models.TagSynonym TagSynonymInput = ExpressionTreeFixture.Create<Benchmark.Models.TagSynonym>();
+
+        protected static readonly Benchmark.Models.TagWiki TagWikiInput = ExpressionTreeFixture.Create<Benchmark.Models.TagWiki>();
+
+        protected static readonly Benchmark.Models.TopTag TopTagInput = ExpressionTreeFixture.Create<Benchmark.Models.TopTag>();
+
+        protected static readonly Benchmark.Models.User UserInput = ExpressionTreeFixture.Create<Benchmark.Models.User>();
+
+        protected static readonly Benchmark.Models.UserTimeline UserTimelineInput = ExpressionTreeFixture.Create<Benchmark.Models.UserTimeline>();
+
+        protected static readonly Benchmark.Models.WritePermission WritePermissionInput = ExpressionTreeFixture.Create<Benchmark.Models.WritePermission>();
+
+        protected static readonly Benchmark.Models.MobileBannerAd.MobileBannerAdImage MobileBannerAdImageInput = ExpressionTreeFixture.Create<Benchmark.Models.MobileBannerAd.MobileBannerAdImage>();
+
+        protected static readonly Benchmark.Models.Info.Site SiteInput = ExpressionTreeFixture.Create<Benchmark.Models.Info.Site>();
+
+        protected static readonly Benchmark.Models.Info.RelatedSite RelatedSiteInput = ExpressionTreeFixture.Create<Benchmark.Models.Info.RelatedSite>();
+
+        protected static readonly Benchmark.Models.Question.ClosedDetails ClosedDetailsInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.ClosedDetails>();
+
+        protected static readonly Benchmark.Models.Question.Notice NoticeInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.Notice>();
+
+        protected static readonly Benchmark.Models.Question.MigrationInfo MigrationInfoInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.MigrationInfo>();
+
+        protected static readonly Benchmark.Models.User.BadgeCount BadgeCountInput = ExpressionTreeFixture.Create<Benchmark.Models.User.BadgeCount>();
+
+        protected static readonly Benchmark.Models.Info.Site.Styling StylingInput = ExpressionTreeFixture.Create<Benchmark.Models.Info.Site.Styling>();
+
+        protected static readonly Benchmark.Models.Question.ClosedDetails.OriginalQuestion OriginalQuestionInput = ExpressionTreeFixture.Create<Benchmark.Models.Question.ClosedDetails.OriginalQuestion>();
+
+        private object SByteOutput;
+        private object ShortOutput;
+        private object IntOutput;
+        private object LongOutput;
+        private object ByteOutput;
+        private object UShortOutput;
+        private object UIntOutput;
+        private object ULongOutput;
+        private object BoolOutput;
+        private object StringOutput;
+        private object CharOutput;
+        private object DateTimeOutput;
+        private object GuidOutput;
+        private object BytesOutput;
+
+        private object AccessTokenOutput;
+        private object AccountMergeOutput;
+        private object AnswerOutput;
+        private object BadgeOutput;
+        private object CommentOutput;
+        private object ErrorOutput;
+        private object EventOutput;
+        private object MobileFeedOutput;
+        private object MobileQuestionOutput;
+        private object MobileRepChangeOutput;
+        private object MobileInboxItemOutput;
+        private object MobileBadgeAwardOutput;
+        private object MobilePrivilegeOutput;
+        private object MobileCommunityBulletinOutput;
+        private object MobileAssociationBonusOutput;
+        private object MobileCareersJobAdOutput;
+        private object MobileBannerAdOutput;
+        private object MobileUpdateNoticeOutput;
+        private object FlagOptionOutput;
+        private object InboxItemOutput;
+        private object InfoOutput;
+        private object NetworkUserOutput;
+        private object NotificationOutput;
+        private object PostOutput;
+        private object PrivilegeOutput;
+        private object QuestionOutput;
+        private object QuestionTimelineOutput;
+        private object ReputationOutput;
+        private object ReputationHistoryOutput;
+        private object RevisionOutput;
+        private object SearchExcerptOutput;
+        private object ShallowUserOutput;
+        private object SuggestedEditOutput;
+        private object TagOutput;
+        private object TagScoreOutput;
+        private object TagSynonymOutput;
+        private object TagWikiOutput;
+        private object TopTagOutput;
+        private object UserOutput;
+        private object UserTimelineOutput;
+        private object WritePermissionOutput;
+        private object MobileBannerAdImageOutput;
+        private object SiteOutput;
+        private object RelatedSiteOutput;
+        private object ClosedDetailsOutput;
+        private object NoticeOutput;
+        private object MigrationInfoOutput;
+        private object BadgeCountOutput;
+        private object StylingOutput;
+        private object OriginalQuestionOutput;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            // primitives
+            this.SByteOutput = this.Serializer.Serialize(SByteInput);
+            this.ShortOutput = this.Serializer.Serialize(ShortInput);
+            this.IntOutput = this.Serializer.Serialize(IntInput);
+            this.LongOutput = this.Serializer.Serialize(LongInput);
+            this.ByteOutput = this.Serializer.Serialize(ByteInput);
+            this.UShortOutput = this.Serializer.Serialize(UShortInput);
+            this.UIntOutput = this.Serializer.Serialize(UIntInput);
+            this.ULongOutput = this.Serializer.Serialize(ULongInput);
+            this.BoolOutput = this.Serializer.Serialize(BoolInput);
+            this.StringOutput = this.Serializer.Serialize(StringInput);
+            this.CharOutput = this.Serializer.Serialize(CharInput);
+            this.DateTimeOutput = this.Serializer.Serialize(DateTimeInput);
+            this.GuidOutput = this.Serializer.Serialize(GuidInput);
+            this.BytesOutput = this.Serializer.Serialize(BytesInput);
+
+            // models
+            this.AccessTokenOutput = this.Serializer.Serialize(AccessTokenInput);
+            this.AccountMergeOutput = this.Serializer.Serialize(AccountMergeInput);
+            this.AnswerOutput = this.Serializer.Serialize(AnswerInput);
+            this.BadgeOutput = this.Serializer.Serialize(BadgeInput);
+            this.CommentOutput = this.Serializer.Serialize(CommentInput);
+            this.ErrorOutput = this.Serializer.Serialize(ErrorInput);
+            this.EventOutput = this.Serializer.Serialize(EventInput);
+            this.MobileFeedOutput = this.Serializer.Serialize(MobileFeedInput);
+            this.MobileQuestionOutput = this.Serializer.Serialize(MobileQuestionInput);
+            this.MobileRepChangeOutput = this.Serializer.Serialize(MobileRepChangeInput);
+            this.MobileInboxItemOutput = this.Serializer.Serialize(MobileInboxItemInput);
+            this.MobileBadgeAwardOutput = this.Serializer.Serialize(MobileBadgeAwardInput);
+            this.MobilePrivilegeOutput = this.Serializer.Serialize(MobilePrivilegeInput);
+            this.MobileCommunityBulletinOutput = this.Serializer.Serialize(MobileCommunityBulletinInput);
+            this.MobileAssociationBonusOutput = this.Serializer.Serialize(MobileAssociationBonusInput);
+            this.MobileCareersJobAdOutput = this.Serializer.Serialize(MobileCareersJobAdInput);
+            this.MobileBannerAdOutput = this.Serializer.Serialize(MobileBannerAdInput);
+            this.MobileUpdateNoticeOutput = this.Serializer.Serialize(MobileUpdateNoticeInput);
+            this.FlagOptionOutput = this.Serializer.Serialize(FlagOptionInput);
+            this.InboxItemOutput = this.Serializer.Serialize(InboxItemInput);
+            this.InfoOutput = this.Serializer.Serialize(InfoInput);
+            this.NetworkUserOutput = this.Serializer.Serialize(NetworkUserInput);
+            this.NotificationOutput = this.Serializer.Serialize(NotificationInput);
+            this.PostOutput = this.Serializer.Serialize(PostInput);
+            this.PrivilegeOutput = this.Serializer.Serialize(PrivilegeInput);
+            this.QuestionOutput = this.Serializer.Serialize(QuestionInput);
+            this.QuestionTimelineOutput = this.Serializer.Serialize(QuestionTimelineInput);
+            this.ReputationOutput = this.Serializer.Serialize(ReputationInput);
+            this.ReputationHistoryOutput = this.Serializer.Serialize(ReputationHistoryInput);
+            this.RevisionOutput = this.Serializer.Serialize(RevisionInput);
+            this.SearchExcerptOutput = this.Serializer.Serialize(SearchExcerptInput);
+            this.ShallowUserOutput = this.Serializer.Serialize(ShallowUserInput);
+            this.SuggestedEditOutput = this.Serializer.Serialize(SuggestedEditInput);
+            this.TagOutput = this.Serializer.Serialize(TagInput);
+            this.TagScoreOutput = this.Serializer.Serialize(TagScoreInput);
+            this.TagSynonymOutput = this.Serializer.Serialize(TagSynonymInput);
+            this.TagWikiOutput = this.Serializer.Serialize(TagWikiInput);
+            this.TopTagOutput = this.Serializer.Serialize(TopTagInput);
+            this.UserOutput = this.Serializer.Serialize(UserInput);
+            this.UserTimelineOutput = this.Serializer.Serialize(UserTimelineInput);
+            this.WritePermissionOutput = this.Serializer.Serialize(WritePermissionInput);
+            this.MobileBannerAdImageOutput = this.Serializer.Serialize(MobileBannerAdImageInput);
+            this.SiteOutput = this.Serializer.Serialize(SiteInput);
+            this.RelatedSiteOutput = this.Serializer.Serialize(RelatedSiteInput);
+            this.ClosedDetailsOutput = this.Serializer.Serialize(ClosedDetailsInput);
+            this.NoticeOutput = this.Serializer.Serialize(NoticeInput);
+            this.MigrationInfoOutput = this.Serializer.Serialize(MigrationInfoInput);
+            this.BadgeCountOutput = this.Serializer.Serialize(BadgeCountInput);
+            this.StylingOutput = this.Serializer.Serialize(StylingInput);
+            this.OriginalQuestionOutput = this.Serializer.Serialize(OriginalQuestionInput);
+        }
+
+        // Serialize
+        [Benchmark] public object _PrimitiveSByteSerialize() => this.Serializer.Serialize(SByteInput);
+
+        [Benchmark] public object _PrimitiveShortSerialize() => this.Serializer.Serialize(ShortInput);
+
+        [Benchmark] public object _PrimitiveIntSerialize() => this.Serializer.Serialize(IntInput);
+
+        [Benchmark] public object _PrimitiveLongSerialize() => this.Serializer.Serialize(LongInput);
+
+        [Benchmark] public object _PrimitiveByteSerialize() => this.Serializer.Serialize(ByteInput);
+
+        [Benchmark] public object _PrimitiveUShortSerialize() => this.Serializer.Serialize(UShortInput);
+
+        [Benchmark] public object _PrimitiveUIntSerialize() => this.Serializer.Serialize(UIntInput);
+
+        [Benchmark] public object _PrimitiveULongSerialize() => this.Serializer.Serialize(ULongInput);
+
+        [Benchmark] public object _PrimitiveBoolSerialize() => this.Serializer.Serialize(BoolInput);
+
+        [Benchmark] public object _PrimitiveStringSerialize() => this.Serializer.Serialize(StringInput);
+
+        [Benchmark] public object _PrimitiveCharSerialize() => this.Serializer.Serialize(CharInput);
+
+        [Benchmark] public object _PrimitiveDateTimeSerialize() => this.Serializer.Serialize(DateTimeInput);
+
+        [Benchmark] public object _PrimitiveGuidSerialize() => this.Serializer.Serialize(GuidInput);
+
+        [Benchmark] public object _PrimitiveBytesSerialize() => this.Serializer.Serialize(BytesInput);
+
+        [Benchmark] public object AccessTokenSerialize() => this.Serializer.Serialize(AccessTokenInput);
+
+        [Benchmark] public object AccountMergeSerialize() => this.Serializer.Serialize(AccountMergeInput);
+
+        [Benchmark] public object AnswerSerialize() => this.Serializer.Serialize(AnswerInput);
+
+        [Benchmark] public object BadgeSerialize() => this.Serializer.Serialize(BadgeInput);
+
+        [Benchmark] public object CommentSerialize() => this.Serializer.Serialize(CommentInput);
+
+        [Benchmark] public object ErrorSerialize() => this.Serializer.Serialize(ErrorInput);
+
+        [Benchmark] public object EventSerialize() => this.Serializer.Serialize(EventInput);
+
+        [Benchmark] public object MobileFeedSerialize() => this.Serializer.Serialize(MobileFeedInput);
+
+        [Benchmark] public object MobileQuestionSerialize() => this.Serializer.Serialize(MobileQuestionInput);
+
+        [Benchmark] public object MobileRepChangeSerialize() => this.Serializer.Serialize(MobileRepChangeInput);
+
+        [Benchmark] public object MobileInboxItemSerialize() => this.Serializer.Serialize(MobileInboxItemInput);
+
+        [Benchmark] public object MobileBadgeAwardSerialize() => this.Serializer.Serialize(MobileBadgeAwardInput);
+
+        [Benchmark] public object MobilePrivilegeSerialize() => this.Serializer.Serialize(MobilePrivilegeInput);
+
+        [Benchmark] public object MobileCommunityBulletinSerialize() => this.Serializer.Serialize(MobileCommunityBulletinInput);
+
+        [Benchmark] public object MobileAssociationBonusSerialize() => this.Serializer.Serialize(MobileAssociationBonusInput);
+
+        [Benchmark] public object MobileCareersJobAdSerialize() => this.Serializer.Serialize(MobileCareersJobAdInput);
+
+        [Benchmark] public object MobileBannerAdSerialize() => this.Serializer.Serialize(MobileBannerAdInput);
+
+        [Benchmark] public object MobileUpdateNoticeSerialize() => this.Serializer.Serialize(MobileUpdateNoticeInput);
+
+        [Benchmark] public object FlagOptionSerialize() => this.Serializer.Serialize(FlagOptionInput);
+
+        [Benchmark] public object InboxItemSerialize() => this.Serializer.Serialize(InboxItemInput);
+
+        [Benchmark] public object InfoSerialize() => this.Serializer.Serialize(InfoInput);
+
+        [Benchmark] public object NetworkUserSerialize() => this.Serializer.Serialize(NetworkUserInput);
+
+        [Benchmark] public object NotificationSerialize() => this.Serializer.Serialize(NotificationInput);
+
+        [Benchmark] public object PostSerialize() => this.Serializer.Serialize(PostInput);
+
+        [Benchmark] public object PrivilegeSerialize() => this.Serializer.Serialize(PrivilegeInput);
+
+        [Benchmark] public object QuestionSerialize() => this.Serializer.Serialize(QuestionInput);
+
+        [Benchmark] public object QuestionTimelineSerialize() => this.Serializer.Serialize(QuestionTimelineInput);
+
+        [Benchmark] public object ReputationSerialize() => this.Serializer.Serialize(ReputationInput);
+
+        [Benchmark] public object ReputationHistorySerialize() => this.Serializer.Serialize(ReputationHistoryInput);
+
+        [Benchmark] public object RevisionSerialize() => this.Serializer.Serialize(RevisionInput);
+
+        [Benchmark] public object SearchExcerptSerialize() => this.Serializer.Serialize(SearchExcerptInput);
+
+        [Benchmark] public object ShallowUserSerialize() => this.Serializer.Serialize(ShallowUserInput);
+
+        [Benchmark] public object SuggestedEditSerialize() => this.Serializer.Serialize(SuggestedEditInput);
+
+        [Benchmark] public object TagSerialize() => this.Serializer.Serialize(TagInput);
+
+        [Benchmark] public object TagScoreSerialize() => this.Serializer.Serialize(TagScoreInput);
+
+        [Benchmark] public object TagSynonymSerialize() => this.Serializer.Serialize(TagSynonymInput);
+
+        [Benchmark] public object TagWikiSerialize() => this.Serializer.Serialize(TagWikiInput);
+
+        [Benchmark] public object TopTagSerialize() => this.Serializer.Serialize(TopTagInput);
+
+        [Benchmark] public object UserSerialize() => this.Serializer.Serialize(UserInput);
+
+        [Benchmark] public object UserTimelineSerialize() => this.Serializer.Serialize(UserTimelineInput);
+
+        [Benchmark] public object WritePermissionSerialize() => this.Serializer.Serialize(WritePermissionInput);
+
+        [Benchmark] public object MobileBannerAdImageSerialize() => this.Serializer.Serialize(MobileBannerAdImageInput);
+
+        [Benchmark] public object SiteSerialize() => this.Serializer.Serialize(SiteInput);
+
+        [Benchmark] public object RelatedSiteSerialize() => this.Serializer.Serialize(RelatedSiteInput);
+
+        [Benchmark] public object ClosedDetailsSerialize() => this.Serializer.Serialize(ClosedDetailsInput);
+
+        [Benchmark] public object NoticeSerialize() => this.Serializer.Serialize(NoticeInput);
+
+        [Benchmark] public object MigrationInfoSerialize() => this.Serializer.Serialize(MigrationInfoInput);
+
+        [Benchmark] public object BadgeCountSerialize() => this.Serializer.Serialize(BadgeCountInput);
+
+        [Benchmark] public object StylingSerialize() => this.Serializer.Serialize(StylingInput);
+
+        [Benchmark] public object OriginalQuestionSerialize() => this.Serializer.Serialize(OriginalQuestionInput);
+
+        // Deserialize
+        [Benchmark] public SByte _PrimitiveSByteDeserialize() => this.Serializer.Deserialize<SByte>(this.SByteOutput);
+
+        [Benchmark] public short _PrimitiveShortDeserialize() => this.Serializer.Deserialize<short>(this.ShortOutput);
+
+        [Benchmark] public Int32 _PrimitiveIntDeserialize() => this.Serializer.Deserialize<Int32>(this.IntOutput);
+
+        [Benchmark] public Int64 _PrimitiveLongDeserialize() => this.Serializer.Deserialize<Int64>(this.LongOutput);
+
+        [Benchmark] public Byte _PrimitiveByteDeserialize() => this.Serializer.Deserialize<Byte>(this.ByteOutput);
+
+        [Benchmark] public ushort _PrimitiveUShortDeserialize() => this.Serializer.Deserialize<ushort>(this.UShortOutput);
+
+        [Benchmark] public uint _PrimitiveUIntDeserialize() => this.Serializer.Deserialize<uint>(this.UIntOutput);
+
+        [Benchmark] public ulong _PrimitiveULongDeserialize() => this.Serializer.Deserialize<ulong>(this.ULongOutput);
+
+        [Benchmark] public bool _PrimitiveBoolDeserialize() => this.Serializer.Deserialize<bool>(this.BoolOutput);
+
+        [Benchmark] public String _PrimitiveStringDeserialize() => this.Serializer.Deserialize<String>(this.StringOutput);
+
+        [Benchmark] public Char _PrimitiveCharDeserialize() => this.Serializer.Deserialize<Char>(this.CharOutput);
+
+        [Benchmark] public DateTime _PrimitiveDateTimeDeserialize() => this.Serializer.Deserialize<DateTime>(this.DateTimeOutput);
+
+        [Benchmark] public Guid _PrimitiveGuidDeserialize() => this.Serializer.Deserialize<Guid>(this.GuidOutput);
+
+        [Benchmark] public byte[] _PrimitiveBytesDeserialize() => this.Serializer.Deserialize<byte[]>(this.BytesOutput);
+
+        [Benchmark] public AccessToken AccessTokenDeserialize() => this.Serializer.Deserialize<AccessToken>(this.AccessTokenOutput);
+
+        [Benchmark] public AccountMerge AccountMergeDeserialize() => this.Serializer.Deserialize<AccountMerge>(this.AccountMergeOutput);
+
+        [Benchmark] public Answer AnswerDeserialize() => this.Serializer.Deserialize<Answer>(this.AnswerOutput);
+
+        [Benchmark] public Badge BadgeDeserialize() => this.Serializer.Deserialize<Badge>(this.BadgeOutput);
+
+        [Benchmark] public Comment CommentDeserialize() => this.Serializer.Deserialize<Comment>(this.CommentOutput);
+
+        [Benchmark] public Error ErrorDeserialize() => this.Serializer.Deserialize<Error>(this.ErrorOutput);
+
+        [Benchmark] public Event EventDeserialize() => this.Serializer.Deserialize<Event>(this.EventOutput);
+
+        [Benchmark] public MobileFeed MobileFeedDeserialize() => this.Serializer.Deserialize<MobileFeed>(this.MobileFeedOutput);
+
+        [Benchmark] public MobileQuestion MobileQuestionDeserialize() => this.Serializer.Deserialize<MobileQuestion>(this.MobileQuestionOutput);
+
+        [Benchmark] public MobileRepChange MobileRepChangeDeserialize() => this.Serializer.Deserialize<MobileRepChange>(this.MobileRepChangeOutput);
+
+        [Benchmark] public MobileInboxItem MobileInboxItemDeserialize() => this.Serializer.Deserialize<MobileInboxItem>(this.MobileInboxItemOutput);
+
+        [Benchmark] public MobileBadgeAward MobileBadgeAwardDeserialize() => this.Serializer.Deserialize<MobileBadgeAward>(this.MobileBadgeAwardOutput);
+
+        [Benchmark] public MobilePrivilege MobilePrivilegeDeserialize() => this.Serializer.Deserialize<MobilePrivilege>(this.MobilePrivilegeOutput);
+
+        [Benchmark] public MobileCommunityBulletin MobileCommunityBulletinDeserialize() => this.Serializer.Deserialize<MobileCommunityBulletin>(this.MobileCommunityBulletinOutput);
+
+        [Benchmark] public MobileAssociationBonus MobileAssociationBonusDeserialize() => this.Serializer.Deserialize<MobileAssociationBonus>(this.MobileAssociationBonusOutput);
+
+        [Benchmark] public MobileCareersJobAd MobileCareersJobAdDeserialize() => this.Serializer.Deserialize<MobileCareersJobAd>(this.MobileCareersJobAdOutput);
+
+        [Benchmark] public MobileBannerAd MobileBannerAdDeserialize() => this.Serializer.Deserialize<MobileBannerAd>(this.MobileBannerAdOutput);
+
+        [Benchmark] public MobileUpdateNotice MobileUpdateNoticeDeserialize() => this.Serializer.Deserialize<MobileUpdateNotice>(this.MobileUpdateNoticeOutput);
+
+        [Benchmark] public FlagOption FlagOptionDeserialize() => this.Serializer.Deserialize<FlagOption>(this.FlagOptionOutput);
+
+        [Benchmark] public InboxItem InboxItemDeserialize() => this.Serializer.Deserialize<InboxItem>(this.InboxItemOutput);
+
+        [Benchmark] public Info InfoDeserialize() => this.Serializer.Deserialize<Info>(this.InfoOutput);
+
+        [Benchmark] public NetworkUser NetworkUserDeserialize() => this.Serializer.Deserialize<NetworkUser>(this.NetworkUserOutput);
+
+        [Benchmark] public Notification NotificationDeserialize() => this.Serializer.Deserialize<Notification>(this.NotificationOutput);
+
+        [Benchmark] public Post PostDeserialize() => this.Serializer.Deserialize<Post>(this.PostOutput);
+
+        [Benchmark] public Privilege PrivilegeDeserialize() => this.Serializer.Deserialize<Privilege>(this.PrivilegeOutput);
+
+        [Benchmark] public Question QuestionDeserialize() => this.Serializer.Deserialize<Question>(this.QuestionOutput);
+
+        [Benchmark] public QuestionTimeline QuestionTimelineDeserialize() => this.Serializer.Deserialize<QuestionTimeline>(this.QuestionTimelineOutput);
+
+        [Benchmark] public Reputation ReputationDeserialize() => this.Serializer.Deserialize<Reputation>(this.ReputationOutput);
+
+        [Benchmark] public ReputationHistory ReputationHistoryDeserialize() => this.Serializer.Deserialize<ReputationHistory>(this.ReputationHistoryOutput);
+
+        [Benchmark] public Revision RevisionDeserialize() => this.Serializer.Deserialize<Revision>(this.RevisionOutput);
+
+        [Benchmark] public SearchExcerpt SearchExcerptDeserialize() => this.Serializer.Deserialize<SearchExcerpt>(this.SearchExcerptOutput);
+
+        [Benchmark] public ShallowUser ShallowUserDeserialize() => this.Serializer.Deserialize<ShallowUser>(this.ShallowUserOutput);
+
+        [Benchmark] public SuggestedEdit SuggestedEditDeserialize() => this.Serializer.Deserialize<SuggestedEdit>(this.SuggestedEditOutput);
+
+        [Benchmark] public Tag TagDeserialize() => this.Serializer.Deserialize<Tag>(this.TagOutput);
+
+        [Benchmark] public TagScore TagScoreDeserialize() => this.Serializer.Deserialize<TagScore>(this.TagScoreOutput);
+
+        [Benchmark] public TagSynonym TagSynonymDeserialize() => this.Serializer.Deserialize<TagSynonym>(this.TagSynonymOutput);
+
+        [Benchmark] public TagWiki TagWikiDeserialize() => this.Serializer.Deserialize<TagWiki>(this.TagWikiOutput);
+
+        [Benchmark] public TopTag TopTagDeserialize() => this.Serializer.Deserialize<TopTag>(this.TopTagOutput);
+
+        [Benchmark] public User UserDeserialize() => this.Serializer.Deserialize<User>(this.UserOutput);
+
+        [Benchmark] public UserTimeline UserTimelineDeserialize() => this.Serializer.Deserialize<UserTimeline>(this.UserTimelineOutput);
+
+        [Benchmark] public WritePermission WritePermissionDeserialize() => this.Serializer.Deserialize<WritePermission>(this.WritePermissionOutput);
+
+        [Benchmark] public MobileBannerAd.MobileBannerAdImage MobileBannerAdImageDeserialize() => this.Serializer.Deserialize<MobileBannerAd.MobileBannerAdImage>(this.MobileBannerAdImageOutput);
+
+        [Benchmark] public Info.Site SiteDeserialize() => this.Serializer.Deserialize<Info.Site>(this.SiteOutput);
+
+        [Benchmark] public Info.RelatedSite RelatedSiteDeserialize() => this.Serializer.Deserialize<Info.RelatedSite>(this.RelatedSiteOutput);
+
+        [Benchmark] public Question.ClosedDetails ClosedDetailsDeserialize() => this.Serializer.Deserialize<Question.ClosedDetails>(this.ClosedDetailsOutput);
+
+        [Benchmark] public Question.Notice NoticeDeserialize() => this.Serializer.Deserialize<Question.Notice>(this.NoticeOutput);
+
+        [Benchmark] public Question.MigrationInfo MigrationInfoDeserialize() => this.Serializer.Deserialize<Question.MigrationInfo>(this.MigrationInfoOutput);
+
+        [Benchmark] public User.BadgeCount BadgeCountDeserialize() => this.Serializer.Deserialize<User.BadgeCount>(this.BadgeCountOutput);
+
+        [Benchmark] public Info.Site.Styling StylingDeserialize() => this.Serializer.Deserialize<Info.Site.Styling>(this.StylingOutput);
+
+        [Benchmark] public Question.ClosedDetails.OriginalQuestion OriginalQuestionDeserialize() => this.Serializer.Deserialize<Question.ClosedDetails.OriginalQuestion>(this.OriginalQuestionOutput);
+    }
+
+    [Config(typeof(BenchmarkConfig))]
+    public class ShortRun_AllSerializerBenchmark_BytesInOut
+    {
+        [ParamsSource(nameof(Serializers))]
+        public SerializerBase Serializer;
+
+        private bool isContractless;
+
+        // Currently BenchmarkdDotNet does not detect inherited ParamsSource so use copy and paste:)
+        public IEnumerable<SerializerBase> Serializers => new SerializerBase[]
+        {
+            new MessagePack_v2(),
+            new MsgPack_v2_opt(),
+            new MessagePackLz4_v2(),
+            new MsgPack_v2_string(),
+            new MsgPack_v2_str_lz4(),
+            new ProtobufNet(),
+            new JsonNet(),
+            new BinaryFormatter_(),
+            new DataContract_(),
+            new Hyperion_(),
+            new Jil_(),
+            new SpanJson_(),
+            new Utf8Json_(),
+            new SystemTextJson(),
+			new MsgPackCli(),
+			new MsgPackCli_v2(),
+            new FsPickler_(),
+            new Ceras_(),
+        };
+
+        protected static readonly ExpressionTreeFixture ExpressionTreeFixture = new ExpressionTreeFixture();
+
+        // primitives
+        protected static readonly int IntInput = ExpressionTreeFixture.Create<int>();
+
+        // models
+        protected static readonly Benchmark.Models.Answer AnswerInput = ExpressionTreeFixture.Create<Benchmark.Models.Answer>();
+        // not same data so does not gurantee correctly.
+        protected static readonly Benchmark.Models.Answer2 Answer2Input = ExpressionTreeFixture.Create<Benchmark.Models.Answer2>();
+
+        private object IntOutput;
+        private object AnswerOutput;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            this.isContractless = (Serializer is MsgPack_v2_string) || (Serializer is MsgPack_v2_str_lz4);
+
+            // primitives
+            this.IntOutput = this.Serializer.Serialize(IntInput);
+
+            // models
+            if (isContractless)
+            {
+                this.AnswerOutput = this.Serializer.Serialize(Answer2Input);
+            }
+            else
+            {
+                this.AnswerOutput = this.Serializer.Serialize(AnswerInput);
+            }
+        }
+
+        // Serialize
+        /* [Benchmark] public object _PrimitiveIntSerialize() => this.Serializer.Serialize(IntInput); */
+
+        [Benchmark]
+        public object AnswerSerialize()
+        {
+            if (isContractless)
+            {
+                return this.Serializer.Serialize(Answer2Input);
+            }
+            else
+            {
+                return this.Serializer.Serialize(AnswerInput);
+            }
+        }
+
+        // Deserialize
+        /* [Benchmark] public Int32 _PrimitiveIntDeserialize() => this.Serializer.Deserialize<Int32>(this.IntOutput); */
+
+        [Benchmark]
+        public object AnswerDeserialize()
+        {
+            if (isContractless)
+            {
+                return this.Serializer.Deserialize<Answer2>(this.AnswerOutput);
+            }
+            else
+            {
+                return this.Serializer.Deserialize<Answer>(this.AnswerOutput);
+            }
+        }
+    }
+
+    [Config(typeof(BenchmarkConfig))]
+    public class ShortRun_MsgPackV1_Vs_MsgPackV2_BytesInOut
+    {
+        [ParamsSource(nameof(Serializers))]
+        public SerializerBase Serializer;
+
+        // Currently BenchmarkdDotNet does not detect inherited ParamsSource so use copy and paste:)
+        public IEnumerable<SerializerBase> Serializers => new SerializerBase[]
+        {
+            new MsgPackCli(),
+            new MsgPackCli_v2(),
+        };
+
+        protected static readonly ExpressionTreeFixture ExpressionTreeFixture = new ExpressionTreeFixture();
+
+        // primitives
+        protected static readonly int IntInput = ExpressionTreeFixture.Create<int>();
+
+        // models
+        protected static readonly Benchmark.Models.Answer AnswerInput = ExpressionTreeFixture.Create<Benchmark.Models.Answer>();
+
+        private object IntOutput;
+        private object AnswerOutput;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            // primitives
+            this.IntOutput = this.Serializer.Serialize(IntInput);
+
+            // models
+            this.AnswerOutput = this.Serializer.Serialize(AnswerInput);
+        }
+
+        // Serialize
+        [Benchmark] public object _PrimitiveIntSerialize() => this.Serializer.Serialize(IntInput);
+
+        [Benchmark] public object AnswerSerialize() => this.Serializer.Serialize(AnswerInput);
+
+        // Deserialize
+        [Benchmark] public Int32 _PrimitiveIntDeserialize() => this.Serializer.Deserialize<Int32>(this.IntOutput);
+
+        [Benchmark] public Answer AnswerDeserialize() => this.Serializer.Deserialize<Answer>(this.AnswerOutput);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/BinaryFormatter.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/BinaryFormatter.cs
new file mode 100644
index 000000000..b3981a890
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/BinaryFormatter.cs
@@ -0,0 +1,29 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class BinaryFormatter_ : SerializerBase
+{
+    public override T Deserialize<T>(object input)
+    {
+        using (var ms = new MemoryStream((byte[])input))
+        {
+            return (T)new BinaryFormatter().Deserialize(ms);
+        }
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        using (var ms = new MemoryStream())
+        {
+            new BinaryFormatter().Serialize(ms, input);
+            ms.Flush();
+            return ms.ToArray();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/CerasSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/CerasSerializer.cs
new file mode 100644
index 000000000..cfdd9be09
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/CerasSerializer.cs
@@ -0,0 +1,21 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class Ceras_ : SerializerBase
+{
+    private Ceras.CerasSerializer ceras = new Ceras.CerasSerializer();
+
+    public override T Deserialize<T>(object input)
+    {
+        return this.ceras.Deserialize<T>((byte[])input);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return this.ceras.Serialize(input);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/DataContractSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/DataContractSerializer.cs
new file mode 100644
index 000000000..eae1431ff
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/DataContractSerializer.cs
@@ -0,0 +1,29 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using System.Runtime.Serialization;
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class DataContract_ : SerializerBase
+{
+    public override T Deserialize<T>(object input)
+    {
+        using (var ms = new MemoryStream((byte[])input))
+        {
+            return (T)new DataContractSerializer(typeof(T)).ReadObject(ms);
+        }
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        using (var ms = new MemoryStream())
+        {
+            new DataContractSerializer(typeof(T)).WriteObject(ms, input);
+            ms.Flush();
+            return ms.ToArray();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/FsPicklerSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/FsPicklerSerializer.cs
new file mode 100644
index 000000000..18b1c88e8
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/FsPicklerSerializer.cs
@@ -0,0 +1,31 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using Benchmark.Serializers;
+using MBrace.FsPickler;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class FsPickler_ : SerializerBase
+{
+    private static readonly BinarySerializer Serializer = MBrace.FsPickler.FsPickler.CreateBinarySerializer();
+
+    public override T Deserialize<T>(object input)
+    {
+        using (var ms = new MemoryStream((byte[])input))
+        {
+            return Serializer.Deserialize<T>(ms);
+        }
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        using (var ms = new MemoryStream())
+        {
+            Serializer.Serialize<T>(ms, input);
+            ms.Flush();
+            return ms.ToArray();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HagarSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HagarSerializer.cs
new file mode 100644
index 000000000..9a33c7d05
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HagarSerializer.cs
@@ -0,0 +1,59 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+////using Benchmark.Serializers;
+////using System.Buffers;
+////using Hagar;
+////using Hagar.Buffers;
+////using Hagar.Session;
+////using Microsoft.Extensions.DependencyInjection;
+////using System.IO.Pipelines;
+
+////public class Hagar_ : SerializerBase
+////{
+////    readonly ServiceProvider serviceProvider;
+
+////    public Hagar_()
+////    {
+////        this.serviceProvider = new ServiceCollection()
+////            .AddHagar()
+////            .AddISerializableSupport()
+////            .AddSerializers(typeof(Hagar_).Assembly) // this assembly
+////            .BuildServiceProvider();
+////    }
+
+////    public override T Deserialize<T>(object input)
+////    {
+////        var serializer = serviceProvider.GetRequiredService<Serializer<T>>();
+////        var sessionPool = serviceProvider.GetRequiredService<SessionPool>();
+
+////        var pipe = new Pipe();
+////        pipe.Writer.WriteAsync((byte[])input).GetAwaiter().GetResult();
+////        pipe.Writer.Complete();
+
+////        using (var session = sessionPool.GetSession())
+////        {
+////            pipe.Reader.TryRead(out var readResult);
+////            var reader = new Reader(readResult.Buffer, session);
+////            var result = serializer.Deserialize(ref reader);
+////            return result;
+////        }
+////    }
+
+////    public override object Serialize<T>(T input)
+////    {
+////        var serializer = serviceProvider.GetRequiredService<Serializer<T>>();
+////        var sessionPool = serviceProvider.GetRequiredService<SessionPool>();
+
+////        var pipe = new Pipe();
+
+////        using (var session = sessionPool.GetSession())
+////        {
+////            var writer = pipe.Writer.CreateWriter(session);
+////            serializer.Serialize(ref writer, input);
+////            pipe.Writer.Complete();
+////            pipe.Reader.TryRead(out var result);
+////            return result.Buffer.ToArray();
+////        }
+////    }
+////}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HyperionSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HyperionSerializer.cs
new file mode 100644
index 000000000..b38ef9494
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/HyperionSerializer.cs
@@ -0,0 +1,31 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using Benchmark.Serializers;
+using Hyperion;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class Hyperion_ : SerializerBase
+{
+    private static readonly Serializer Serializer = new Hyperion.Serializer();
+
+    public override T Deserialize<T>(object input)
+    {
+        using (var ms = new MemoryStream((byte[])input))
+        {
+            return Serializer.Deserialize<T>(ms);
+        }
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        using (var ms = new MemoryStream())
+        {
+            Serializer.Serialize(input, ms);
+            ms.Flush();
+            return ms.ToArray();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JilSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JilSerializer.cs
new file mode 100644
index 000000000..b68a0585f
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JilSerializer.cs
@@ -0,0 +1,21 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Text;
+using Benchmark.Serializers;
+using Jil;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class Jil_ : SerializerBase
+{
+    public override object Serialize<T>(T input)
+    {
+        return Encoding.UTF8.GetBytes(Jil.JSON.Serialize(input, Options.ISO8601));
+    }
+
+    public override T Deserialize<T>(object input)
+    {
+        return Jil.JSON.Deserialize<T>(Encoding.UTF8.GetString((byte[])input), Options.ISO8601);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JsonNetSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JsonNetSerializer.cs
new file mode 100644
index 000000000..80761c6a4
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/JsonNetSerializer.cs
@@ -0,0 +1,39 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using System.Text;
+using Benchmark.Serializers;
+using Newtonsoft.Json;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class JsonNet : SerializerBase
+{
+    private static readonly JsonSerializer Serializer = new JsonSerializer();
+
+    public override T Deserialize<T>(object input)
+    {
+        using (var ms = new MemoryStream((byte[])input))
+        using (var sr = new StreamReader(ms, Encoding.UTF8))
+        using (var jr = new JsonTextReader(sr))
+        {
+            return Serializer.Deserialize<T>(jr);
+        }
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        using (var ms = new MemoryStream())
+        {
+            using (var sw = new StreamWriter(ms, Encoding.UTF8))
+            using (var jw = new JsonTextWriter(sw))
+            {
+                Serializer.Serialize(jw, input);
+            }
+
+            ms.Flush();
+            return ms.ToArray();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MessagePackSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MessagePackSerializer.cs
new file mode 100644
index 000000000..b3d64acfe
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MessagePackSerializer.cs
@@ -0,0 +1,123 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class MessagePack_v2 : SerializerBase
+{
+    public override T Deserialize<T>(object input)
+    {
+        return MessagePack.MessagePackSerializer.Deserialize<T>((byte[])input);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return MessagePack.MessagePackSerializer.Serialize<T>(input);
+    }
+}
+
+public class MsgPack_v2_string : SerializerBase
+{
+    private static readonly MessagePack.MessagePackSerializerOptions Options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(MessagePack.Resolvers.ContractlessStandardResolver.Instance);
+
+    public override T Deserialize<T>(object input)
+    {
+        return MessagePack.MessagePackSerializer.Deserialize<T>((byte[])input, options: Options);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return MessagePack.MessagePackSerializer.Serialize<T>(input, options: Options);
+    }
+}
+
+public class MessagePackLz4_v2 : SerializerBase
+{
+    private static readonly MessagePack.MessagePackSerializerOptions LZ4BlockArray = MessagePack.MessagePackSerializerOptions.Standard.WithCompression(MessagePack.MessagePackCompression.Lz4BlockArray);
+
+    public override T Deserialize<T>(object input)
+    {
+        return MessagePack.MessagePackSerializer.Deserialize<T>((byte[])input, LZ4BlockArray);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return MessagePack.MessagePackSerializer.Serialize<T>(input, LZ4BlockArray);
+    }
+}
+
+public class MsgPack_v2_str_lz4 : SerializerBase
+{
+    private static readonly MessagePack.MessagePackSerializerOptions Options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(MessagePack.Resolvers.ContractlessStandardResolver.Instance).WithCompression(MessagePack.MessagePackCompression.Lz4BlockArray);
+
+    public override T Deserialize<T>(object input)
+    {
+        return MessagePack.MessagePackSerializer.Deserialize<T>((byte[])input, Options);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return MessagePack.MessagePackSerializer.Serialize<T>(input, Options);
+    }
+}
+
+public class MsgPack_v2_opt : SerializerBase
+{
+    private static readonly MessagePack.MessagePackSerializerOptions Options = MessagePack.MessagePackSerializerOptions.Standard.WithResolver(OptimizedResolver.Instance);
+
+    public override T Deserialize<T>(object input)
+    {
+        return MessagePack.MessagePackSerializer.Deserialize<T>((byte[])input, Options);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return MessagePack.MessagePackSerializer.Serialize<T>(input, Options);
+    }
+}
+
+public class OptimizedResolver : MessagePack.IFormatterResolver
+{
+    public static readonly MessagePack.IFormatterResolver Instance = new OptimizedResolver();
+
+    // configure your custom resolvers.
+    private static readonly MessagePack.IFormatterResolver[] Resolvers = new MessagePack.IFormatterResolver[]
+    {
+        MessagePack.Resolvers.NativeGuidResolver.Instance,
+        MessagePack.Resolvers.NativeDecimalResolver.Instance,
+        MessagePack.Resolvers.NativeDateTimeResolver.Instance,
+        MessagePack.Resolvers.StandardResolver.Instance,
+    };
+
+    private OptimizedResolver()
+    {
+    }
+
+    public MessagePack.Formatters.IMessagePackFormatter<T> GetFormatter<T>()
+    {
+        return Cache<T>.Formatter;
+    }
+
+    private static class Cache<T>
+    {
+#pragma warning disable SA1401 // Fields should be private
+        public static MessagePack.Formatters.IMessagePackFormatter<T> Formatter;
+#pragma warning restore SA1401 // Fields should be private
+
+        static Cache()
+        {
+            foreach (var resolver in Resolvers)
+            {
+                var f = resolver.GetFormatter<T>();
+                if (f != null)
+                {
+                    Formatter = f;
+                    return;
+                }
+            }
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
new file mode 100644
index 000000000..342bb2af9
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
@@ -0,0 +1,20 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+extern alias newmpcli;
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class MsgPackCli : SerializerBase
+{
+    public override T Deserialize<T>(object input)
+    {
+        return MsgPack.Serialization.MessagePackSerializer.Get<T>().UnpackSingleObject((byte[])input);
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        return MsgPack.Serialization.MessagePackSerializer.Get<T>().PackSingleObject(input);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/ProtobufSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/ProtobufSerializer.cs
new file mode 100644
index 000000000..d0394065d
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/ProtobufSerializer.cs
@@ -0,0 +1,29 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using Benchmark.Serializers;
+using ProtoBuf;
+
+public class
+#pragma warning disable SA1649 // File name should match first type name
+
+ProtobufNet : SerializerBase
+{
+    public override T Deserialize<T>(object input)
+    {
+        using (var ms = new MemoryStream((byte[])input))
+        {
+            return Serializer.Deserialize<T>(ms);
+        }
+    }
+
+    public override object Serialize<T>(T input)
+    {
+        using (var ms = new MemoryStream())
+        {
+            Serializer.Serialize(ms, input);
+            return ms.ToArray();
+        }
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SerializerBase.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SerializerBase.cs
new file mode 100644
index 000000000..cd092a77d
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SerializerBase.cs
@@ -0,0 +1,14 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Benchmark.Serializers
+{
+    public abstract class SerializerBase
+    {
+        public abstract object Serialize<T>(T input);
+
+        public abstract T Deserialize<T>(object input);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SpanJsonSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SpanJsonSerializer.cs
new file mode 100644
index 000000000..a3a2f44d7
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SpanJsonSerializer.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class SpanJson_ : SerializerBase
+{
+    public override object Serialize<T>(T input)
+    {
+        return SpanJson.JsonSerializer.Generic.Utf8.Serialize(input);
+    }
+
+    public override T Deserialize<T>(object input)
+    {
+        return SpanJson.JsonSerializer.Generic.Utf8.Deserialize<T>((byte[])input);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SystemTextJsonSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SystemTextJsonSerializer.cs
new file mode 100644
index 000000000..f6358d154
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/SystemTextJsonSerializer.cs
@@ -0,0 +1,20 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class SystemTextJson : SerializerBase
+{
+    public override object Serialize<T>(T input)
+    {
+        return System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(input);
+    }
+
+    public override T Deserialize<T>(object input)
+    {
+        var span = (byte[])input;
+        return System.Text.Json.JsonSerializer.Deserialize<T>(span);
+    }
+}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/Utf8JsonSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/Utf8JsonSerializer.cs
new file mode 100644
index 000000000..f52b0d9b7
--- /dev/null
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/Utf8JsonSerializer.cs
@@ -0,0 +1,19 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Benchmark.Serializers;
+
+#pragma warning disable SA1649 // File name should match first type name
+
+public class Utf8Json_ : SerializerBase
+{
+    public override object Serialize<T>(T input)
+    {
+        return Utf8Json.JsonSerializer.Serialize(input);
+    }
+
+    public override T Deserialize<T>(object input)
+    {
+        return Utf8Json.JsonSerializer.Deserialize<T>((byte[])input);
+    }
+}
diff --git a/test/Benchmark/Readme.md b/test/Benchmark/Readme.md
new file mode 100644
index 000000000..c46cdcca7
--- /dev/null
+++ b/test/Benchmark/Readme.md
@@ -0,0 +1,14 @@
+Benchmark
+===
+
+For fair comparison and utilize their great job, this directory tree is ported from MessagePack for C# (https://github.com/neuecc/MessagePack-CSharp/).
+
+License and Copyright Notice
+---
+
+Files under this directory are licensed under MIT license, not Apache2 license, and note that copyright holders are Yoshifumi Kawai and all MessagePack for C# contributors who include all contributors to this directory.
+
+Acknowledgement
+---
+
+Thank you for their excellent jobs and we truly respect them!

From a8439b4d989c71d57db52e2bd51cab2cc7254c56 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jun 2020 01:18:32 +0900
Subject: [PATCH 23/82] Tune-up to exclude central repository overhead

---
 .../Serializers/MsgPackCliSerializer.cs       | 35 ++++++++++++++-----
 1 file changed, 27 insertions(+), 8 deletions(-)

diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
index 342bb2af9..408bd801c 100644
--- a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
@@ -8,13 +8,32 @@
 
 public class MsgPackCli : SerializerBase
 {
-    public override T Deserialize<T>(object input)
-    {
-        return MsgPack.Serialization.MessagePackSerializer.Get<T>().UnpackSingleObject((byte[])input);
-    }
+	public override T Deserialize<T>(object input)
+	{
+		return MsgPackCliSerializerRepository<T>.V1.UnpackSingleObject((byte[])input);
+	}
 
-    public override object Serialize<T>(T input)
-    {
-        return MsgPack.Serialization.MessagePackSerializer.Get<T>().PackSingleObject(input);
-    }
+	public override object Serialize<T>(T input)
+	{
+		return MsgPackCliSerializerRepository<T>.V1.PackSingleObject(input);
+	}
+}
+public class MsgPackCli_with_Get : SerializerBase
+{
+	public override T Deserialize<T>(object input)
+	{
+		return MsgPack.Serialization.MessagePackSerializer.Get<T>().UnpackSingleObject((byte[])input);
+	}
+
+	public override object Serialize<T>(T input)
+	{
+		return MsgPack.Serialization.MessagePackSerializer.Get<T>().PackSingleObject(input);
+	}
+}
+
+internal static class MsgPackCliSerializerRepository<T>
+{
+	public static readonly MsgPack.Serialization.MessagePackSerializer<T> V1 = SampleSerializer.SerializationContext.GetSerializer<T>();
+
+}
 }

From b016661a76718747203493016a9d88e06c609c87 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jun 2020 01:07:23 +0900
Subject: [PATCH 24/82] Fix prototype v2 serializer primitives

* Redesign API for correct behavior
* Bug fixes found in initial benchmarking
* Tune up to prove whether the architecture is good or not.
---
 .../Internal/CollectionContext.cs             |    8 +-
 .../Internal/CollectionItemIterator.cs        |   22 +-
 .../Internal/CollectionType.cs                |   15 +-
 .../Internal/DecodeItemResult`1.cs            |    2 +-
 .../Internal/Decoder`1.Primitives.cs          |  132 +-
 .../Internal/Decoder`1.Primitives.tt          |   12 +-
 .../Internal/Decoder`1.Strings.cs             |   36 +-
 .../Internal/Decoder`1.Strings.tt             |   12 +-
 src/MsgPack.Abstraction/Internal/Decoder`1.cs |   87 +-
 .../Internal/Encoder`1.Primitives.cs          |   14 +-
 .../Internal/Encoder`1.Primitives.tt          |    2 +-
 src/MsgPack.Abstraction/Internal/Encoder`1.cs |    7 +-
 src/MsgPack.Abstraction/Internal/Ensure.cs    |   10 +-
 .../Internal/OptionsDefaults.cs               |    5 +
 .../Internal/StreamBufferWriter.cs            |    2 +-
 .../Internal/StreamReadOnlyMemoryProvider.cs  |    2 +-
 src/MsgPack.Abstraction/Internal/Throw.cs     |   19 +
 .../MsgPack.Abstraction.csproj                |   36 +
 .../Serialization/DeserializationOptions.cs   |    4 +-
 .../DeserializationOptionsBuilder.cs          |   14 +-
 .../AsyncDeserializationOperationContext`1.cs |   69 +
 .../AsyncDeserializationOperationContext`1.tt |    6 +
 .../AsyncSerializationOperationContext`1.cs   |   59 +
 .../AsyncSerializationOperationContext`1.tt   |    6 +
 .../DeserializationOperationContext`1.cs      |   19 +-
 .../DeserializationOperationContext`1.tt      |    6 +
 .../Internal/IObjectSerializer`2.cs           |   12 +-
 .../Internal/OperationContext.ttinclude       |  111 +
 .../SerializationOperationContext`1.cs        |   25 +-
 .../SerializationOperationContext`1.tt        |    6 +
 .../SerializationOptionsBuilder.cs            |    2 +-
 .../Serialization/Serializer`2.cs             |   54 +-
 .../Internal/CurrentMessagePackEncoder.cs     |   21 +-
 .../Internal/LegacyMessagePackEncoder.cs      |   10 +
 .../MessagePackDecoder.CollectionHeaders.cs   |   82 +-
 .../Internal/MessagePackDecoder.DecodeItem.cs |   54 +-
 .../Internal/MessagePackDecoder.Extension.cs  |   16 +-
 .../Internal/MessagePackDecoder.Integers.cs   |  103 +-
 .../Internal/MessagePackDecoder.Integers.tt   |   24 +-
 .../Internal/MessagePackDecoder.Iteration.cs  |   15 +-
 .../Internal/MessagePackDecoder.Nullables.cs  |   66 +-
 .../Internal/MessagePackDecoder.Nullables.tt  |    6 +-
 .../MessagePackDecoder.Number.ttinclude       |    8 +-
 .../Internal/MessagePackDecoder.Reals.cs      |   52 +-
 .../Internal/MessagePackDecoder.Reals.tt      |   12 +-
 .../Internal/MessagePackDecoder.SkipDrain.cs  |   55 +-
 .../Internal/MessagePackDecoder.Strings.cs    |   78 +-
 .../Internal/MessagePackDecoder.cs            |   41 +-
 .../Internal/MessagePackEncoder.Integers.cs   |    8 +-
 .../Internal/MessagePackEncoder.Integers.tt   |    2 +-
 .../Internal/MessagePackEncoder.Strings.cs    |   31 +-
 .../Internal/MessagePackEncoder.Strings.tt    |   13 +-
 .../Internal/MessagePackEncoder.cs            |   18 +-
 .../Internal/MsgPackStringTrie`1.cs           |  354 ++-
 src/MsgPack.Core/System.Text/Throw.cs         |   14 +
 .../Json/FlexibleJsonDecoder.ReadTrivia.cs    |   64 +-
 src/MsgPack.Json/Json/FlexibleJsonDecoder.cs  |   26 +-
 src/MsgPack.Json/Json/JsonCharactor.cs        |    1 +
 .../Json/JsonDecoder.CollectionHeaders.cs     |    7 +-
 .../Json/JsonDecoder.DecodeItem.cs            |   43 +-
 .../Json/JsonDecoder.Iteration.cs             |   48 +-
 .../Json/JsonDecoder.Nullables.cs             |   88 +-
 .../Json/JsonDecoder.Nullables.tt             |    8 +-
 .../Json/JsonDecoder.NumberCore.cs            |  195 +-
 src/MsgPack.Json/Json/JsonDecoder.Numbers.cs  |  100 +-
 src/MsgPack.Json/Json/JsonDecoder.Numbers.tt  |   10 +-
 .../Json/JsonDecoder.SkipDrain.cs             |   11 +-
 src/MsgPack.Json/Json/JsonDecoder.Strings.cs  |  271 +-
 src/MsgPack.Json/Json/JsonDecoder.cs          |   22 +-
 src/MsgPack.Json/Json/JsonDecoderOptions.cs   |    2 +
 src/MsgPack.Json/Json/JsonEncoder.cs          |  715 +++---
 src/MsgPack.Json/Json/JsonEncoderOptions.cs   |   12 +-
 .../Json/JsonEncoderOptionsBuilder.cs         |    5 +-
 .../Json/JsonEscapeSequence.EscapeTables.cs   | 2186 +++++++++++++++++
 .../Json/JsonEscapeSequence.EscapeTables.tt   |  218 ++
 src/MsgPack.Json/Json/JsonEscapeSequence.cs   |    2 +-
 src/MsgPack.Json/Json/JsonFormatter.cs        |   18 +-
 src/MsgPack.Json/Json/JsonNumberTokens.cs     |   95 -
 src/MsgPack.Json/Json/JsonStringTokens.cs     |   26 -
 src/MsgPack.Json/Json/JsonThrow.cs            |    4 +-
 src/MsgPack.Json/Json/JsonTokens.cs           |   29 -
 src/MsgPack.Json/Json/JsonTriviaTokens.cs     |   12 -
 src/MsgPack.Json/Json/SimpleJsonDecoder.cs    |   28 +-
 .../Json/StringBuilderBufferWriter.cs         |    3 +-
 src/MsgPack.Json/MsgPack.Json.csproj          |   20 +-
 85 files changed, 4767 insertions(+), 1401 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.tt
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.tt
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.tt
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude
 create mode 100644 src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.tt
 create mode 100644 src/MsgPack.Core/System.Text/Throw.cs
 create mode 100644 src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.cs
 create mode 100644 src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.tt
 delete mode 100644 src/MsgPack.Json/Json/JsonNumberTokens.cs
 delete mode 100644 src/MsgPack.Json/Json/JsonTokens.cs

diff --git a/src/MsgPack.Abstraction/Internal/CollectionContext.cs b/src/MsgPack.Abstraction/Internal/CollectionContext.cs
index 8b2cdb5d5..75b82355e 100644
--- a/src/MsgPack.Abstraction/Internal/CollectionContext.cs
+++ b/src/MsgPack.Abstraction/Internal/CollectionContext.cs
@@ -2,17 +2,15 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
-using MsgPack.Serialization;
-
 namespace MsgPack.Internal
 {
 	public partial struct CollectionContext
 	{
 		public static CollectionContext Default =>
 			new CollectionContext(
-				DeserializationOptionsBuilder.DefaultMaxArrayLength,
-				DeserializationOptionsBuilder.DefaultMaxMapCount,
-				DeserializationOptionsBuilder.DefaultMaxDepth,
+				OptionsDefaults.MaxArrayLength,
+				OptionsDefaults.MaxMapCount,
+				OptionsDefaults.MaxDepth,
 				currentDepth: 0
 			);
 
diff --git a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
index ddf24be47..9fa613652 100644
--- a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
+++ b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
@@ -10,7 +10,7 @@ namespace MsgPack.Internal
 {
 	public struct CollectionItemIterator
 	{
-		public delegate bool CollectionEndDetection(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint);
+		public delegate bool CollectionEndDetection(ref SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint);
 
 		private readonly long _itemsCount;
 		private long _nextItemIndex;
@@ -27,9 +27,9 @@ long itemsCount
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public bool CollectionEnds(in SequenceReader<byte> source)
+		public bool CollectionEnds(ref SequenceReader<byte> source)
 		{
-			var result = this._collectionEnds(source, ref this._nextItemIndex, this._itemsCount, out var requestHint);
+			var result = this._collectionEnds(ref source, ref this._nextItemIndex, this._itemsCount, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDetectCollectionEnds(source.Consumed, requestHint);
@@ -39,29 +39,29 @@ public bool CollectionEnds(in SequenceReader<byte> source)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public bool CollectionEnds(in SequenceReader<byte> source, out int requestHint)
-			=> this._collectionEnds(source, ref this._nextItemIndex, this._itemsCount, out requestHint);
+		public bool CollectionEnds(ref SequenceReader<byte> source, out int requestHint)
+			=> this._collectionEnds(ref source, ref this._nextItemIndex, this._itemsCount, out requestHint);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public bool CollectionEnds(ReadOnlyMemory<byte> source, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(source));
-			return this.CollectionEnds(reader, out requestHint);
+			return this.CollectionEnds(ref reader, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public void Drain(in SequenceReader<byte> source)
+		public void Drain(ref SequenceReader<byte> source)
 		{
-			if (!this.Drain(source, out var requestHint))
+			if (!this.Drain(ref source, out var requestHint))
 			{
 				Throw.InsufficientInputForDrainCollectionItems(source.Consumed, requestHint);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public bool Drain(in SequenceReader<byte> source, out int requestHint)
+		public bool Drain(ref SequenceReader<byte> source, out int requestHint)
 		{
-			while (!this.CollectionEnds(source, out requestHint))
+			while (!this.CollectionEnds(ref source, out requestHint))
 			{
 				if (requestHint != 0)
 				{
@@ -76,7 +76,7 @@ public bool Drain(in SequenceReader<byte> source, out int requestHint)
 		public bool Drain(ref ReadOnlyMemory<byte> source, out int requestHint)
 		{
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(source));
-			var ends = this.Drain(reader, out requestHint);
+			var ends = this.Drain(ref reader, out requestHint);
 			source = source.Slice((int)reader.Consumed);
 			return ends;
 		}
diff --git a/src/MsgPack.Abstraction/Internal/CollectionType.cs b/src/MsgPack.Abstraction/Internal/CollectionType.cs
index 1875b8472..ad9a9fadd 100644
--- a/src/MsgPack.Abstraction/Internal/CollectionType.cs
+++ b/src/MsgPack.Abstraction/Internal/CollectionType.cs
@@ -13,23 +13,30 @@ namespace MsgPack.Internal
 	public readonly struct CollectionType : IEquatable<CollectionType>
 	{
 		public static readonly CollectionType None = default;
-		public static readonly CollectionType Array = new CollectionType(1);
-		public static readonly CollectionType Map = new CollectionType(2);
+		public static readonly CollectionType Null = new CollectionType(1);
+		public static readonly CollectionType Array = new CollectionType(2);
+		public static readonly CollectionType Map = new CollectionType(3);
 
 		private readonly int _type;
 
-		public bool IsArray
+		public bool IsNull
 		{
 			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 			get => this._type == 1;
 		}
 
-		public bool IsMap
+		public bool IsArray
 		{
 			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 			get => this._type == 2;
 		}
 
+		public bool IsMap
+		{
+			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+			get => this._type == 3;
+		}
+
 		public bool IsNone
 		{
 			[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
diff --git a/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs b/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
index 96e2d8db7..42749053b 100644
--- a/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
+++ b/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
@@ -9,7 +9,7 @@
 namespace MsgPack.Internal
 {
 	/// <summary>
-	///		Represetns a result of <see cref="Decoder.DecodeItem"/>.
+	///		Represents a result of <see cref="Decoder.DecodeItem"/>.
 	/// </summary>
 	public readonly struct DecodeItemResult<TExtensionType>
 	{
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
index 8c4d48b33..7765926f1 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
@@ -29,9 +29,9 @@ partial class Decoder<TExtensionType>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Byte DecodeByte(in SequenceReader<byte> source)
+		public Byte DecodeByte(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeByte(source, out var requestHint);
+			var result = this.DecodeByte(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Byte), requestHint);
@@ -57,7 +57,7 @@ public Byte DecodeByte(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Byte DecodeByte(in SequenceReader<byte> source, out int requestHint);
+		public abstract Byte DecodeByte(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Byte" /> value or <c>null</c> from specified sequence.
@@ -74,9 +74,9 @@ public Byte DecodeByte(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Byte? DecodeNullableByte(in SequenceReader<byte> source)
+		public Byte? DecodeNullableByte(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableByte(source, out var requestHint);
+			var result = this.DecodeNullableByte(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Byte), requestHint);
@@ -103,7 +103,7 @@ public Byte DecodeByte(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Byte? DecodeNullableByte(in SequenceReader<byte> source, out int requestHint);
+		public abstract Byte? DecodeNullableByte(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="Int16" /> value from specified sequence.
@@ -120,9 +120,9 @@ public Byte DecodeByte(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Int16 DecodeInt16(in SequenceReader<byte> source)
+		public Int16 DecodeInt16(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeInt16(source, out var requestHint);
+			var result = this.DecodeInt16(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Int16), requestHint);
@@ -148,7 +148,7 @@ public Int16 DecodeInt16(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Int16 DecodeInt16(in SequenceReader<byte> source, out int requestHint);
+		public abstract Int16 DecodeInt16(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Int16" /> value or <c>null</c> from specified sequence.
@@ -165,9 +165,9 @@ public Int16 DecodeInt16(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Int16? DecodeNullableInt16(in SequenceReader<byte> source)
+		public Int16? DecodeNullableInt16(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableInt16(source, out var requestHint);
+			var result = this.DecodeNullableInt16(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Int16), requestHint);
@@ -194,7 +194,7 @@ public Int16 DecodeInt16(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Int16? DecodeNullableInt16(in SequenceReader<byte> source, out int requestHint);
+		public abstract Int16? DecodeNullableInt16(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="Int32" /> value from specified sequence.
@@ -211,9 +211,9 @@ public Int16 DecodeInt16(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Int32 DecodeInt32(in SequenceReader<byte> source)
+		public Int32 DecodeInt32(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeInt32(source, out var requestHint);
+			var result = this.DecodeInt32(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Int32), requestHint);
@@ -239,7 +239,7 @@ public Int32 DecodeInt32(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Int32 DecodeInt32(in SequenceReader<byte> source, out int requestHint);
+		public abstract Int32 DecodeInt32(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Int32" /> value or <c>null</c> from specified sequence.
@@ -256,9 +256,9 @@ public Int32 DecodeInt32(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Int32? DecodeNullableInt32(in SequenceReader<byte> source)
+		public Int32? DecodeNullableInt32(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableInt32(source, out var requestHint);
+			var result = this.DecodeNullableInt32(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Int32), requestHint);
@@ -285,7 +285,7 @@ public Int32 DecodeInt32(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Int32? DecodeNullableInt32(in SequenceReader<byte> source, out int requestHint);
+		public abstract Int32? DecodeNullableInt32(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="Int64" /> value from specified sequence.
@@ -302,9 +302,9 @@ public Int32 DecodeInt32(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Int64 DecodeInt64(in SequenceReader<byte> source)
+		public Int64 DecodeInt64(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeInt64(source, out var requestHint);
+			var result = this.DecodeInt64(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Int64), requestHint);
@@ -330,7 +330,7 @@ public Int64 DecodeInt64(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Int64 DecodeInt64(in SequenceReader<byte> source, out int requestHint);
+		public abstract Int64 DecodeInt64(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Int64" /> value or <c>null</c> from specified sequence.
@@ -347,9 +347,9 @@ public Int64 DecodeInt64(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Int64? DecodeNullableInt64(in SequenceReader<byte> source)
+		public Int64? DecodeNullableInt64(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableInt64(source, out var requestHint);
+			var result = this.DecodeNullableInt64(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Int64), requestHint);
@@ -376,7 +376,7 @@ public Int64 DecodeInt64(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Int64? DecodeNullableInt64(in SequenceReader<byte> source, out int requestHint);
+		public abstract Int64? DecodeNullableInt64(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="SByte" /> value from specified sequence.
@@ -393,9 +393,9 @@ public Int64 DecodeInt64(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public SByte DecodeSByte(in SequenceReader<byte> source)
+		public SByte DecodeSByte(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeSByte(source, out var requestHint);
+			var result = this.DecodeSByte(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(SByte), requestHint);
@@ -421,7 +421,7 @@ public SByte DecodeSByte(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract SByte DecodeSByte(in SequenceReader<byte> source, out int requestHint);
+		public abstract SByte DecodeSByte(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="SByte" /> value or <c>null</c> from specified sequence.
@@ -438,9 +438,9 @@ public SByte DecodeSByte(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public SByte? DecodeNullableSByte(in SequenceReader<byte> source)
+		public SByte? DecodeNullableSByte(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableSByte(source, out var requestHint);
+			var result = this.DecodeNullableSByte(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(SByte), requestHint);
@@ -467,7 +467,7 @@ public SByte DecodeSByte(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract SByte? DecodeNullableSByte(in SequenceReader<byte> source, out int requestHint);
+		public abstract SByte? DecodeNullableSByte(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="UInt16" /> value from specified sequence.
@@ -484,9 +484,9 @@ public SByte DecodeSByte(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public UInt16 DecodeUInt16(in SequenceReader<byte> source)
+		public UInt16 DecodeUInt16(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeUInt16(source, out var requestHint);
+			var result = this.DecodeUInt16(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(UInt16), requestHint);
@@ -512,7 +512,7 @@ public UInt16 DecodeUInt16(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract UInt16 DecodeUInt16(in SequenceReader<byte> source, out int requestHint);
+		public abstract UInt16 DecodeUInt16(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="UInt16" /> value or <c>null</c> from specified sequence.
@@ -529,9 +529,9 @@ public UInt16 DecodeUInt16(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public UInt16? DecodeNullableUInt16(in SequenceReader<byte> source)
+		public UInt16? DecodeNullableUInt16(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableUInt16(source, out var requestHint);
+			var result = this.DecodeNullableUInt16(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(UInt16), requestHint);
@@ -558,7 +558,7 @@ public UInt16 DecodeUInt16(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract UInt16? DecodeNullableUInt16(in SequenceReader<byte> source, out int requestHint);
+		public abstract UInt16? DecodeNullableUInt16(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="UInt32" /> value from specified sequence.
@@ -575,9 +575,9 @@ public UInt16 DecodeUInt16(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public UInt32 DecodeUInt32(in SequenceReader<byte> source)
+		public UInt32 DecodeUInt32(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeUInt32(source, out var requestHint);
+			var result = this.DecodeUInt32(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(UInt32), requestHint);
@@ -603,7 +603,7 @@ public UInt32 DecodeUInt32(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract UInt32 DecodeUInt32(in SequenceReader<byte> source, out int requestHint);
+		public abstract UInt32 DecodeUInt32(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="UInt32" /> value or <c>null</c> from specified sequence.
@@ -620,9 +620,9 @@ public UInt32 DecodeUInt32(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public UInt32? DecodeNullableUInt32(in SequenceReader<byte> source)
+		public UInt32? DecodeNullableUInt32(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableUInt32(source, out var requestHint);
+			var result = this.DecodeNullableUInt32(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(UInt32), requestHint);
@@ -649,7 +649,7 @@ public UInt32 DecodeUInt32(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract UInt32? DecodeNullableUInt32(in SequenceReader<byte> source, out int requestHint);
+		public abstract UInt32? DecodeNullableUInt32(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="UInt64" /> value from specified sequence.
@@ -666,9 +666,9 @@ public UInt32 DecodeUInt32(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public UInt64 DecodeUInt64(in SequenceReader<byte> source)
+		public UInt64 DecodeUInt64(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeUInt64(source, out var requestHint);
+			var result = this.DecodeUInt64(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(UInt64), requestHint);
@@ -694,7 +694,7 @@ public UInt64 DecodeUInt64(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract UInt64 DecodeUInt64(in SequenceReader<byte> source, out int requestHint);
+		public abstract UInt64 DecodeUInt64(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="UInt64" /> value or <c>null</c> from specified sequence.
@@ -711,9 +711,9 @@ public UInt64 DecodeUInt64(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public UInt64? DecodeNullableUInt64(in SequenceReader<byte> source)
+		public UInt64? DecodeNullableUInt64(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableUInt64(source, out var requestHint);
+			var result = this.DecodeNullableUInt64(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(UInt64), requestHint);
@@ -740,7 +740,7 @@ public UInt64 DecodeUInt64(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract UInt64? DecodeNullableUInt64(in SequenceReader<byte> source, out int requestHint);
+		public abstract UInt64? DecodeNullableUInt64(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="Single" /> value from specified sequence.
@@ -757,9 +757,9 @@ public UInt64 DecodeUInt64(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Single DecodeSingle(in SequenceReader<byte> source)
+		public Single DecodeSingle(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeSingle(source, out var requestHint);
+			var result = this.DecodeSingle(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Single), requestHint);
@@ -785,7 +785,7 @@ public Single DecodeSingle(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Single DecodeSingle(in SequenceReader<byte> source, out int requestHint);
+		public abstract Single DecodeSingle(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Single" /> value or <c>null</c> from specified sequence.
@@ -802,9 +802,9 @@ public Single DecodeSingle(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Single? DecodeNullableSingle(in SequenceReader<byte> source)
+		public Single? DecodeNullableSingle(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableSingle(source, out var requestHint);
+			var result = this.DecodeNullableSingle(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Single), requestHint);
@@ -831,7 +831,7 @@ public Single DecodeSingle(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Single? DecodeNullableSingle(in SequenceReader<byte> source, out int requestHint);
+		public abstract Single? DecodeNullableSingle(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="Double" /> value from specified sequence.
@@ -848,9 +848,9 @@ public Single DecodeSingle(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Double DecodeDouble(in SequenceReader<byte> source)
+		public Double DecodeDouble(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeDouble(source, out var requestHint);
+			var result = this.DecodeDouble(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Double), requestHint);
@@ -876,7 +876,7 @@ public Double DecodeDouble(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Double DecodeDouble(in SequenceReader<byte> source, out int requestHint);
+		public abstract Double DecodeDouble(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Double" /> value or <c>null</c> from specified sequence.
@@ -893,9 +893,9 @@ public Double DecodeDouble(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Double? DecodeNullableDouble(in SequenceReader<byte> source)
+		public Double? DecodeNullableDouble(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableDouble(source, out var requestHint);
+			var result = this.DecodeNullableDouble(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Double), requestHint);
@@ -922,7 +922,7 @@ public Double DecodeDouble(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Double? DecodeNullableDouble(in SequenceReader<byte> source, out int requestHint);
+		public abstract Double? DecodeNullableDouble(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes <see cref="Boolean" /> value from specified sequence.
@@ -939,9 +939,9 @@ public Double DecodeDouble(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Boolean DecodeBoolean(in SequenceReader<byte> source)
+		public Boolean DecodeBoolean(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeBoolean(source, out var requestHint);
+			var result = this.DecodeBoolean(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Boolean), requestHint);
@@ -967,7 +967,7 @@ public Boolean DecodeBoolean(in SequenceReader<byte> source)
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Boolean DecodeBoolean(in SequenceReader<byte> source, out int requestHint);
+		public abstract Boolean DecodeBoolean(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="Boolean" /> value or <c>null</c> from specified sequence.
@@ -984,9 +984,9 @@ public Boolean DecodeBoolean(in SequenceReader<byte> source)
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Boolean? DecodeNullableBoolean(in SequenceReader<byte> source)
+		public Boolean? DecodeNullableBoolean(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullableBoolean(source, out var requestHint);
+			var result = this.DecodeNullableBoolean(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(Boolean), requestHint);
@@ -1013,7 +1013,7 @@ public Boolean DecodeBoolean(in SequenceReader<byte> source)
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Boolean? DecodeNullableBoolean(in SequenceReader<byte> source, out int requestHint);
+		public abstract Boolean? DecodeNullableBoolean(ref SequenceReader<byte> source, out int requestHint);
 
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
index c814ebe99..0544c21c5 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
@@ -47,9 +47,9 @@ foreach (var outputType in new [] {
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public <#= outputType #> Decode<#= outputType #>(in SequenceReader<byte> source)
+		public <#= outputType #> Decode<#= outputType #>(ref SequenceReader<byte> source)
 		{
-			var result = this.Decode<#= outputType #>(source, out var requestHint);
+			var result = this.Decode<#= outputType #>(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(<#= outputType #>), requestHint);
@@ -75,7 +75,7 @@ foreach (var outputType in new [] {
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract <#= outputType #> Decode<#= outputType #>(in SequenceReader<byte> source, out int requestHint);
+		public abstract <#= outputType #> Decode<#= outputType #>(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Encodes <see cref="<#= outputType #>" /> value or <c>null</c> from specified sequence.
@@ -92,9 +92,9 @@ foreach (var outputType in new [] {
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public <#= outputType #>? DecodeNullable<#= outputType #>(in SequenceReader<byte> source)
+		public <#= outputType #>? DecodeNullable<#= outputType #>(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeNullable<#= outputType #>(source, out var requestHint);
+			var result = this.DecodeNullable<#= outputType #>(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(<#= outputType #>), requestHint);
@@ -121,7 +121,7 @@ foreach (var outputType in new [] {
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract <#= outputType #>? DecodeNullable<#= outputType #>(in SequenceReader<byte> source, out int requestHint);
+		public abstract <#= outputType #>? DecodeNullable<#= outputType #>(ref SequenceReader<byte> source, out int requestHint);
 
 <#
 }
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
index 17c91200f..f9aeb3571 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
@@ -35,9 +35,9 @@ partial class Decoder<TExtensionType>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public String DecodeString(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeString(source, out var requestHint, encoding, cancellationToken);
+			var result = this.DecodeString(ref source, out var requestHint, encoding, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForString(source.Consumed, typeof(String), encoding, requestHint);
@@ -65,7 +65,7 @@ public String DecodeString(in SequenceReader<byte> source, Encoding? encoding =
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract String? DecodeString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+		public abstract String? DecodeString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		///		Decodes <see cref="String" /> value or <c>null</c> from specified sequence.
@@ -83,9 +83,9 @@ public String DecodeString(in SequenceReader<byte> source, Encoding? encoding =
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public String? DecodeNullableString(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public String? DecodeNullableString(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeNullableString(source, out var requestHint, encoding, cancellationToken);
+			var result = this.DecodeNullableString(ref source, out var requestHint, encoding, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForString(source.Consumed, typeof(String), encoding, requestHint);
@@ -113,7 +113,7 @@ public String DecodeString(in SequenceReader<byte> source, Encoding? encoding =
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract String? DecodeNullableString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+		public abstract String? DecodeNullableString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 
 #if FEATURE_UTF8STRING
@@ -135,9 +135,9 @@ public String DecodeString(in SequenceReader<byte> source, Encoding? encoding =
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Utf8String DecodeUtf8String(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeUtf8String(source, out var requestHint, encoding, cancellationToken);
+			var result = this.DecodeUtf8String(ref source, out var requestHint, encoding, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForUtf8String(source.Consumed, typeof(Utf8String), encoding, requestHint);
@@ -165,7 +165,7 @@ public Utf8String DecodeUtf8String(in SequenceReader<byte> source, Encoding? enc
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract Utf8String? DecodeUtf8String(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+		public abstract Utf8String? DecodeUtf8String(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		///		Decodes <see cref="Utf8String" /> value or <c>null</c> from specified sequence.
@@ -183,9 +183,9 @@ public Utf8String DecodeUtf8String(in SequenceReader<byte> source, Encoding? enc
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public Utf8String? DecodeNullableUtf8String(in SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public Utf8String? DecodeNullableUtf8String(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeNullableUtf8String(source, out var requestHint, encoding, cancellationToken);
+			var result = this.DecodeNullableUtf8String(ref source, out var requestHint, encoding, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForUtf8String(source.Consumed, typeof(Utf8String), encoding, requestHint);
@@ -213,7 +213,7 @@ public Utf8String DecodeUtf8String(in SequenceReader<byte> source, Encoding? enc
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract Utf8String? DecodeNullableUtf8String(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+		public abstract Utf8String? DecodeNullableUtf8String(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 
 #endif // FEATURE_UTF8STRING
@@ -234,9 +234,9 @@ public Utf8String DecodeUtf8String(in SequenceReader<byte> source, Encoding? enc
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public byte[] DecodeBinary(in SequenceReader<byte> source, CancellationToken cancellationToken = default)
+		public byte[] DecodeBinary(ref SequenceReader<byte> source, CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeBinary(source, out var requestHint, cancellationToken);
+			var result = this.DecodeBinary(ref source, out var requestHint, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(byte[]), requestHint);
@@ -263,7 +263,7 @@ public byte[] DecodeBinary(in SequenceReader<byte> source, CancellationToken can
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract byte[]? DecodeBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
+		public abstract byte[]? DecodeBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		///		Decodes <see cref="byte[]" /> value or <c>null</c> from specified sequence.
@@ -280,9 +280,9 @@ public byte[] DecodeBinary(in SequenceReader<byte> source, CancellationToken can
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public byte[]? DecodeNullableBinary(in SequenceReader<byte> source, CancellationToken cancellationToken = default)
+		public byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeNullableBinary(source, out var requestHint, cancellationToken);
+			var result = this.DecodeNullableBinary(ref source, out var requestHint, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput(source.Consumed, typeof(byte[]), requestHint);
@@ -309,7 +309,7 @@ public byte[] DecodeBinary(in SequenceReader<byte> source, CancellationToken can
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract byte[]? DecodeNullableBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
+		public abstract byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
 
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
index ad9ec6506..f731b08a9 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
@@ -78,9 +78,9 @@ foreach (var spec in new [] {
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public <#= spec.Type #> Decode<#= spec.Name #>(in SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
+		public <#= spec.Type #> Decode<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
 		{
-			var result = this.Decode<#= spec.Name #>(source, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
+			var result = this.Decode<#= spec.Name #>(ref source, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput<#= spec.ThrowSuffix #>(source.Consumed, typeof(<#= spec.Type #>), <#= spec.ExtraArguments #>requestHint);
@@ -115,7 +115,7 @@ foreach (var spec in new [] {
 		/// </remarks>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
-		public abstract <#= spec.Type #>? Decode<#= spec.Name #>(in SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
+		public abstract <#= spec.Type #>? Decode<#= spec.Name #>(ref SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
 
 		/// <summary>
 		///		Decodes <see cref="<#= spec.Type #>" /> value or <c>null</c> from specified sequence.
@@ -140,9 +140,9 @@ foreach (var spec in new [] {
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public <#= spec.Type #>? DecodeNullable<#= spec.Name #>(in SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
+		public <#= spec.Type #>? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
 		{
-			var result = this.DecodeNullable<#= spec.Name #>(source, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
+			var result = this.DecodeNullable<#= spec.Name #>(ref source, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInput<#= spec.ThrowSuffix #>(source.Consumed, typeof(<#= spec.Type #>), <#= spec.ExtraArguments #>requestHint);
@@ -177,7 +177,7 @@ foreach (var spec in new [] {
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
 		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract <#= spec.Type #>? DecodeNullable<#= spec.Name #>(in SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
+		public abstract <#= spec.Type #>? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
 
 <#
 	if (!String.IsNullOrEmpty(spec.IfDef))
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.cs b/src/MsgPack.Abstraction/Internal/Decoder`1.cs
index 74d52cfc0..271fd0ee9 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.cs
+++ b/src/MsgPack.Abstraction/Internal/Decoder`1.cs
@@ -30,32 +30,49 @@ protected Decoder(DecoderOptions options, FormatFeatures formatFeatures)
 			this.FormatFeatures = Ensure.NotNull(formatFeatures);
 		}
 
-		public void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, CancellationToken cancellationToken = default)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void Skip(ref SequenceReader<byte> source, in CollectionContext collectionContext, CancellationToken cancellationToken = default)
 		{
-			this.Skip(source, collectionContext, out var requestHint, cancellationToken);
+			this.Skip(ref source, collectionContext, out var requestHint, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForSkip(source.Consumed, requestHint);
 			}
 		}
 
-		public abstract void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default);
-
-		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public bool TryPeek(in SequenceReader<byte> source, out byte value) => source.TryRead(out value);
+		public abstract void Skip(ref SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default);
 
-		public abstract bool DecodeItem(in SequenceReader<byte> source, out DecodeItemResult<TExtensionType> result, CancellationToken cancellationToken = default);
+		public abstract bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult<TExtensionType> result, CancellationToken cancellationToken = default);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public void GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, CancellationToken cancellationToken = default)
+		public void GetRawString(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, CancellationToken cancellationToken = default)
 		{
-			if (!this.GetRawString(source, out rawString, out var requestHint, cancellationToken))
+			if (!this.GetRawString(ref source, out rawString, out var requestHint, cancellationToken))
 			{
 				Throw.InsufficientInputForRawString(source.Consumed, requestHint);
 			}
 		}
 
-		public abstract bool GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default);
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public bool TryDecodeNull(ref SequenceReader<byte> source)
+		{
+			if (this.TryDecodeNull(ref source, out var requestHint))
+			{
+				return true;
+			}
+
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForNull(source.Consumed, requestHint);
+			}
+
+			return false;
+		}
+
+		public abstract bool TryDecodeNull(ref SequenceReader<byte> source, out int requestHint);
+
+
+		public abstract bool GetRawString(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		///		Decodes current data as array or map header, and returns the items count if known.
@@ -69,9 +86,9 @@ public void GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte>
 		///	<exception cref="MessageTypeException">The decoded value is not an array nor a map.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount)
+		public CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount)
 		{
-			var result = this.DecodeArrayOrMapHeader(source, out itemsCount, out var requestHint);
+			var result = this.DecodeArrayOrMapHeader(ref source, out itemsCount, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeArrayOrMapHeader(source.Consumed, requestHint);
@@ -94,7 +111,7 @@ public CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out
 		///		This method does not return anything else, but may throw an exception.
 		///	</returns>
 		///	<exception cref="MessageTypeException">The decoded value is not an array nor a map.</exception>
-		public abstract CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount, out int requestHint);
+		public abstract CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount, out int requestHint);
 
 		/// <summary>
 		///		Decodes current data as array header, and returns the items count if known.
@@ -107,9 +124,9 @@ public CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out
 		///	<exception cref="MessageTypeException">The decoded value is not an array.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public long DecodeArrayHeader(in SequenceReader<byte> source)
+		public long DecodeArrayHeader(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeArrayHeader(source, out var requestHint);
+			var result = this.DecodeArrayHeader(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeArrayHeader(source.Consumed, requestHint);
@@ -132,7 +149,7 @@ public long DecodeArrayHeader(in SequenceReader<byte> source)
 		///	</returns>
 		///	<exception cref="MessageTypeException">The decoded value is not an array.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract long DecodeArrayHeader(in SequenceReader<byte> source, out int requestHint);
+		public abstract long DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes current data as map header, and returns the items count if known.
@@ -145,9 +162,9 @@ public long DecodeArrayHeader(in SequenceReader<byte> source)
 		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public long DecodeMapHeader(in SequenceReader<byte> source)
+		public long DecodeMapHeader(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeMapHeader(source, out var requestHint);
+			var result = this.DecodeMapHeader(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeMapHeader(source.Consumed, requestHint);
@@ -169,9 +186,9 @@ public long DecodeMapHeader(in SequenceReader<byte> source)
 		///		Note that <c>0</c> is valid value when the map is empty.
 		///	</returns>
 		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
-		public abstract long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint);
+		public abstract long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint);
 
-		public virtual void DecodeExtension(in SequenceReader<byte> source, out TExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		public virtual void DecodeExtension(ref SequenceReader<byte> source, out TExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			Throw.ExtensionsIsNotSupported();
 			// never
@@ -180,9 +197,9 @@ public virtual void DecodeExtension(in SequenceReader<byte> source, out TExtensi
 			typeCode = default!;
 		}
 
-		public CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator)
+		public CollectionType DecodeArrayOrMap(ref SequenceReader<byte> source, out CollectionItemIterator iterator)
 		{
-			var result = this.DecodeArrayOrMap(source, out iterator, out var requestHint);
+			var result = this.DecodeArrayOrMap(ref source, out iterator, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeArrayOrMapHeader(source.Consumed, requestHint);
@@ -191,11 +208,11 @@ public CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out Colle
 			return result;
 		}
 
-		public abstract CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint);
+		public abstract CollectionType DecodeArrayOrMap(ref SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint);
 
-		public CollectionItemIterator DecodeArray(in SequenceReader<byte> source)
+		public CollectionItemIterator DecodeArray(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeArray(source, out var requestHint);
+			var result = this.DecodeArray(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeArrayHeader(source.Consumed, requestHint);
@@ -204,11 +221,11 @@ public CollectionItemIterator DecodeArray(in SequenceReader<byte> source)
 			return result;
 		}
 
-		public abstract CollectionItemIterator DecodeArray(in SequenceReader<byte> source, out int requestHint);
+		public abstract CollectionItemIterator DecodeArray(ref SequenceReader<byte> source, out int requestHint);
 
-		public CollectionItemIterator DecodeMap(in SequenceReader<byte> source)
+		public CollectionItemIterator DecodeMap(ref SequenceReader<byte> source)
 		{
-			var result = this.DecodeMap(source, out var requestHint);
+			var result = this.DecodeMap(ref source, out var requestHint);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeMapHeader(source.Consumed, requestHint);
@@ -217,17 +234,23 @@ public CollectionItemIterator DecodeMap(in SequenceReader<byte> source)
 			return result;
 		}
 
-		public abstract CollectionItemIterator DecodeMap(in SequenceReader<byte> source, out int requestHint);
+		public abstract CollectionItemIterator DecodeMap(ref SequenceReader<byte> source, out int requestHint);
 
-		public void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, CancellationToken cancellationToken = default)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void Drain(ref SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, CancellationToken cancellationToken = default)
 		{
-			this.Drain(source, collectionContext, itemsCount, out var requestHint, cancellationToken);
+			if (itemsCount <= 0)
+			{
+				return;
+			}
+
+			this.Drain(ref source, collectionContext, itemsCount, out var requestHint, cancellationToken);
 			if (requestHint != 0)
 			{
 				Throw.InsufficientInputForDecodeMapHeader(source.Consumed, requestHint);
 			}
 		}
 
-		public abstract void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default);
+		public abstract void Drain(ref SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
index 32f4ce55d..bea877506 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
@@ -33,7 +33,7 @@ partial class Encoder<TExtensionType>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeInt32(Int32? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
@@ -63,7 +63,7 @@ public void EncodeInt32(Int32? value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeInt64(Int64? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
@@ -93,7 +93,7 @@ public void EncodeInt64(Int64? value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeUInt32(UInt32? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
@@ -123,7 +123,7 @@ public void EncodeUInt32(UInt32? value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeUInt64(UInt64? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
@@ -153,7 +153,7 @@ public void EncodeUInt64(UInt64? value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeSingle(Single? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
@@ -183,7 +183,7 @@ public void EncodeSingle(Single? value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeDouble(Double? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
@@ -213,7 +213,7 @@ public void EncodeDouble(Double? value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void EncodeBoolean(Boolean? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
diff --git a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
index 4d393c801..84556bc5c 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
@@ -47,7 +47,7 @@ foreach (var inputType in new [] {
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void Encode<#= inputType #>(<#= inputType #>? value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value == null)
 			{
diff --git a/src/MsgPack.Abstraction/Internal/Encoder`1.cs b/src/MsgPack.Abstraction/Internal/Encoder`1.cs
index 55c783099..709e4f1f9 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder`1.cs
+++ b/src/MsgPack.Abstraction/Internal/Encoder`1.cs
@@ -58,6 +58,8 @@ public void EncodeString(string? value, IBufferWriter<byte> buffer, Encoding? en
 
 		public abstract void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
 
+		public abstract void EncodeRawString(ReadOnlySpan<byte> rawString, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
+
 		public abstract void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
 
 		public abstract void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default);
@@ -135,7 +137,7 @@ private static void ThrowBufferWriterReturnsEmptyBuffer(string paramName)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void WriteRaw(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value.Length <= this.Options.MaxByteBufferLength)
 			{
@@ -169,8 +171,5 @@ private static void WriteRawSlow(in ReadOnlySequence<byte> value, IBufferWriter<
 				reader.Advance(source.Length);
 			}
 		}
-
-		private protected static IBufferWriter<byte> EnsureNotNull(IBufferWriter<byte> buffer)
-			=> buffer ?? throw new ArgumentNullException(nameof(buffer));
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/Ensure.cs b/src/MsgPack.Abstraction/Internal/Ensure.cs
index e2a24c72c..379f8e90f 100644
--- a/src/MsgPack.Abstraction/Internal/Ensure.cs
+++ b/src/MsgPack.Abstraction/Internal/Ensure.cs
@@ -3,6 +3,7 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
@@ -15,7 +16,8 @@ public static T NotNull<T>([NotNull]T value, [CallerArgumentExpression("value")]
 		{
 			if (value == null)
 			{
-				throw new ArgumentNullException(paramName);
+				Throw.ArgumentNull(paramName);
+				Debug.Assert(value != null);
 			}
 
 			return value;
@@ -25,7 +27,7 @@ public static int IsNotNegative(int value, [CallerArgumentExpression("value")]st
 		{
 			if (value < 0)
 			{
-				throw new ArgumentOutOfRangeException(paramName, "Value cannot be negative number.");
+				Throw.ArgumentOutOfRange(paramName, "Value cannot be negative number.");
 			}
 
 			return value;
@@ -36,7 +38,7 @@ public static T IsNotLessThan<T>(T value, T minInclusive, [CallerArgumentExpress
 		{
 			if (value.CompareTo(minInclusive) < 0)
 			{
-				throw new ArgumentOutOfRangeException(paramName, $"Value cannot be less than {minInclusive}.");
+				Throw.ArgumentOutOfRange(paramName, $"Value cannot be less than {minInclusive}.");
 			}
 
 			return value;
@@ -47,7 +49,7 @@ public static T IsNotGreaterThan<T>(T value, T maxInclusive, [CallerArgumentExpr
 		{
 			if (value.CompareTo(maxInclusive) > 0)
 			{
-				throw new ArgumentOutOfRangeException(paramName, $"Value cannot be greater than {maxInclusive}.");
+				Throw.ArgumentOutOfRange(paramName, $"Value cannot be greater than {maxInclusive}.");
 			}
 
 			return value;
diff --git a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
index c8fa9fbed..7f470ff1f 100644
--- a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
+++ b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
@@ -6,6 +6,7 @@
 
 namespace MsgPack.Internal
 {
+#warning TODO: tuning default as backward compatible
 	internal static class OptionsDefaults
 	{
 		public static readonly int CancellationSupportThreshold = 128 * 1024 * 1024; // About 0.1 sec in desktop, more for IoT
@@ -14,6 +15,10 @@ internal static class OptionsDefaults
 		public static readonly int MaxBinaryLengthInBytes = 256 * 1024 * 1024;
 		public static readonly int MaxByteBufferLength = 2 * 1024 * 1024;
 		public static readonly int MaxCharBufferLength = 2 * 1024 * 1024;
+		public static readonly int MaxArrayLength = 1024 * 1024;
+		public static readonly int MaxMapCount = 1024 * 1024;
+		public static readonly int MaxPropertyKeyLength = 256;
+		public static readonly int MaxDepth = 100;
 		public static readonly ArrayPool<byte> ByteBufferPool = ArrayPool<byte>.Shared;
 		public static readonly ArrayPool<char> CharBufferPool = ArrayPool<char>.Shared;
 		public static readonly bool ClearsBuffer = true;
diff --git a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
index 975db06c4..ab347a216 100644
--- a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
+++ b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
@@ -10,7 +10,7 @@
 namespace MsgPack.Internal
 {
 #warning TODO: Pubternal or CodeGen
-	internal sealed class StreamBufferWriter : IBufferWriter<byte>, IAsyncDisposable
+	public sealed class StreamBufferWriter : IBufferWriter<byte>, IAsyncDisposable
 	{
 		private readonly Stream _underlying;
 		private readonly bool _ownsStream;
diff --git a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
index c67c81e08..adfd64d77 100644
--- a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
+++ b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
@@ -10,7 +10,7 @@
 namespace MsgPack.Internal
 {
 #warning TODO: PubTernal or CodeGen
-	internal sealed class StreamReadOnlyMemoryProvider
+	public sealed class StreamReadOnlyMemoryProvider
 	{
 		private readonly Stream _stream;
 		private readonly byte[] _buffer;
diff --git a/src/MsgPack.Abstraction/Internal/Throw.cs b/src/MsgPack.Abstraction/Internal/Throw.cs
index 91f780428..929b3670d 100644
--- a/src/MsgPack.Abstraction/Internal/Throw.cs
+++ b/src/MsgPack.Abstraction/Internal/Throw.cs
@@ -9,6 +9,12 @@ namespace MsgPack.Internal
 {
 	internal static class Throw
 	{
+		public static void ArgumentNull(string paramName)
+			=> throw new ArgumentNullException(paramName);
+
+		public static void ArgumentOutOfRange(string paramName, string message)
+			=> throw new ArgumentOutOfRangeException(paramName, message);
+
 		public static void ExtensionsIsNotSupported()
 			=> throw new NotSupportedException($"Extension type is not supported in this encoder.");
 
@@ -51,6 +57,19 @@ public static void InsufficientInput(long position, Type targetType, int request
 			}
 		}
 
+		public static void InsufficientInputForNull(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode null at {position:#,0}.");
+			}
+			else
+			{
+				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode null at {position:#,0}.");
+			}
+		}
+
+
 		public static void InsufficientInputForDecodeArrayOrMapHeader(long position, int requestHint)
 		{
 			if (requestHint < 0)
diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
index efa4c70c2..19123fb42 100644
--- a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -22,6 +22,22 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Decoder`1.Primitives.cs</LastGenOutput>
     </None>
+    <None Update="Serialization\Internal\AsyncSerializationOperationContext`1.tt">
+      <LastGenOutput>AsyncSerializationOperationContext`1.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\Internal\AsyncDeserializationOperationContext`1.tt">
+      <LastGenOutput>AsyncDeserializationOperationContext`1.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\Internal\DeserializationOperationContext`1.tt">
+      <LastGenOutput>DeserializationOperationContext`1.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\Internal\SerializationOperationContext`1.tt">
+      <LastGenOutput>SerializationOperationContext`1.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -44,6 +60,26 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Encoder`1.Primitives.tt</DependentUpon>
     </Compile>
+    <Compile Update="Serialization\Internal\AsyncDeserializationOperationContext`1.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>AsyncDeserializationOperationContext`1.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\Internal\AsyncSerializationOperationContext`1.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>AsyncSerializationOperationContext`1.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\Internal\DeserializationOperationContext`1.cs">
+      <DependentUpon>DeserializationOperationContext`1.tt</DependentUpon>
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </Compile>
+    <Compile Update="Serialization\Internal\SerializationOperationContext`1.cs">
+      <DependentUpon>SerializationOperationContext`1.tt</DependentUpon>
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </Compile>
   </ItemGroup>
   
 </Project>
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
index 7469d883d..7f7f81ccf 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
@@ -16,7 +16,7 @@ public sealed class DeserializationOptions
 		public int MaxPropertyKeyLength { get; }
 		public int MaxDepth { get; }
 		public Encoding? StringEncoding { get; }
-		public ArrayPool<byte> ArrayPool { get; }
+		public ArrayPool<byte> ByteBufferPool { get; }
 
 		internal DeserializationOptions(
 			int maxArrayLength,
@@ -32,7 +32,7 @@ ArrayPool<byte> arrayPool
 			this.MaxPropertyKeyLength = maxPropertyKeyLength;
 			this.MaxDepth = maxDepth;
 			this.StringEncoding = stringEncoding;
-			this.ArrayPool = arrayPool;
+			this.ByteBufferPool = arrayPool;
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
index 54dab8ca0..2bba8d676 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
@@ -8,15 +8,9 @@
 
 namespace MsgPack.Serialization
 {
-#warning TODO: tuning default as backward compatible
 	public sealed class DeserializationOptionsBuilder
 	{
-		internal const int DefaultMaxArrayLength = 1024 * 1024;
-		internal const int DefaultMaxMapCount = 1024 * 1024;
-		internal const int DefaultMaxPropertyKeyLength = 256;
-		internal const int DefaultMaxDepth = 100;
-
-		private int _maxArrayLength = DefaultMaxArrayLength;
+		private int _maxArrayLength = OptionsDefaults.MaxArrayLength;
 
 		public int MaxArrayLength
 		{
@@ -24,7 +18,7 @@ public int MaxArrayLength
 			set => this._maxArrayLength = Ensure.IsNotLessThan(value, 0);
 		}
 
-		private int _maxMapCount = DefaultMaxMapCount;
+		private int _maxMapCount = OptionsDefaults.MaxMapCount;
 
 		public int MaxMapCount
 		{
@@ -32,7 +26,7 @@ public int MaxMapCount
 			set => this._maxMapCount = Ensure.IsNotLessThan(value, 0);
 		}
 
-		private int _maxPropertyKeyLength = DefaultMaxPropertyKeyLength;
+		private int _maxPropertyKeyLength = OptionsDefaults.MaxPropertyKeyLength;
 
 		public int MaxPropertyKeyLength
 		{
@@ -40,7 +34,7 @@ public int MaxPropertyKeyLength
 			set => this._maxPropertyKeyLength = Ensure.IsNotLessThan(value, 1);
 		}
 
-		private int _maxDepth = DefaultMaxDepth;
+		private int _maxDepth = OptionsDefaults.MaxDepth;
 
 		public int MaxDepth
 		{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs
new file mode 100644
index 000000000..58b091d48
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs
@@ -0,0 +1,69 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	public sealed class AsyncDeserializationOperationContext<TExtensionType>
+	{
+		public Decoder<TExtensionType> Decoder { get; }
+		public DeserializationOptions Options { get; }
+		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
+		public int CurrentDepth { get; private set; }
+		public CancellationToken CancellationToken { get; }
+
+		public AsyncDeserializationOperationContext(Decoder<TExtensionType> decoder, DeserializationOptions? options, CancellationToken cancellationToken)
+		{
+			this.Decoder = Ensure.NotNull(decoder);
+			this.Options = options ?? DeserializationOptions.Default;
+			this.CurrentDepth = 0;
+			this.CancellationToken = cancellationToken;
+		}
+
+		public DeserializationOperationContext<TExtensionType> AsDeserializationOperationContext()
+			=> new DeserializationOperationContext<TExtensionType>(this.Decoder, this.Options, this.CancellationToken);
+
+		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
+
+		public int IncrementDepth()
+		{
+			if (this.CurrentDepth == this.Options.MaxDepth)
+			{
+				Throw.DepthExeeded(this.CurrentDepth, this.Options.MaxDepth);
+			}
+
+			return this.CurrentDepth++;
+		}
+
+		public int DecrementDepth()
+		{
+			if (this.CurrentDepth == 0)
+			{
+				Throw.DepthUnderflow();
+			}
+
+			return this.CurrentDepth--;
+		}
+
+		public void ValidatePropertyKeyLength(long position, int length)
+		{
+			if(length > this.Options.MaxPropertyKeyLength)
+			{
+				Throw.TooLargePropertyKey(position, length, this.Options.MaxPropertyKeyLength);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.tt
new file mode 100644
index 000000000..5861989a8
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.tt
@@ -0,0 +1,6 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./OperationContext.ttinclude" #>
+<#@ output extension=".cs" #>
+<#
+WriteContext(isSerialization: false, isAsync: true);
+#>
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs
new file mode 100644
index 000000000..2c358a124
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs
@@ -0,0 +1,59 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	public sealed class AsyncSerializationOperationContext<TExtensionType>
+	{
+		public Encoder<TExtensionType> Encoder { get; }
+		public SerializationOptions Options { get; }
+		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public int CurrentDepth { get; private set; }
+		public CancellationToken CancellationToken { get; }
+
+		public AsyncSerializationOperationContext(Encoder<TExtensionType> encoder, SerializationOptions? options, CancellationToken cancellationToken)
+		{
+			this.Encoder = Ensure.NotNull(encoder);
+			this.Options = options ?? SerializationOptions.Default;
+			this.CurrentDepth = 0;
+			this.CancellationToken = cancellationToken;
+		}
+
+		public SerializationOperationContext<TExtensionType> AsSerializationOperationContext()
+			=> new SerializationOperationContext<TExtensionType>(this.Encoder, this.Options, this.CancellationToken);
+
+		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
+
+		public int IncrementDepth()
+		{
+			if (this.CurrentDepth == this.Options.MaxDepth)
+			{
+				Throw.DepthExeeded(this.CurrentDepth, this.Options.MaxDepth);
+			}
+
+			return this.CurrentDepth++;
+		}
+
+		public int DecrementDepth()
+		{
+			if (this.CurrentDepth == 0)
+			{
+				Throw.DepthUnderflow();
+			}
+
+			return this.CurrentDepth--;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.tt
new file mode 100644
index 000000000..5d6330403
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.tt
@@ -0,0 +1,6 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./OperationContext.ttinclude" #>
+<#@ output extension=".cs" #>
+<#
+WriteContext(isSerialization: true, isAsync: true);
+#>
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
index bac67deb3..fe2014917 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
@@ -2,6 +2,13 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
 using System.Buffers;
 using System.Text;
 using System.Threading;
@@ -13,10 +20,10 @@ public struct DeserializationOperationContext<TExtensionType>
 	{
 		public Decoder<TExtensionType> Decoder { get; }
 		public DeserializationOptions Options { get; }
+		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
-		public ArrayPool<byte> ArrayPool => this.Options.ArrayPool;
-		public Encoding? StringEncoding => this.Options.StringEncoding;
 
 		public DeserializationOperationContext(Decoder<TExtensionType> decoder, DeserializationOptions? options, CancellationToken cancellationToken)
 		{
@@ -26,13 +33,7 @@ public DeserializationOperationContext(Decoder<TExtensionType> decoder, Deserial
 			this.CancellationToken = cancellationToken;
 		}
 
-		public CollectionContext CollectionContext =>
-			new CollectionContext(
-				this.Options.MaxArrayLength, 
-				this.Options.MaxMapCount,
-				this.Options.MaxDepth, 
-				this.CurrentDepth
-			);
+		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
 
 		public int IncrementDepth()
 		{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.tt
new file mode 100644
index 000000000..045ece58c
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.tt
@@ -0,0 +1,6 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./OperationContext.ttinclude" #>
+<#@ output extension=".cs" #>
+<#
+WriteContext(isSerialization: false, isAsync: false);
+#>
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
index 00976498a..762b962da 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
+++ b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
@@ -10,11 +10,11 @@ namespace MsgPack.Serialization.Internal
 {
 	public interface IObjectSerializer<T, TExtentionType>
 	{
-		void Serialize(in SerializationOperationContext<TExtentionType> context, T obj, IBufferWriter<byte> sink);
-		ValueTask SerializeAsync(SerializationOperationContext<TExtentionType> context, T obj, Stream streamSink);
-		T Deserialize(in DeserializationOperationContext<TExtentionType> context, in SequenceReader<byte> source);
-		ValueTask<T> DeserializeAsync(DeserializationOperationContext<TExtentionType> context, Stream streamSource);
-		void DeserializeTo(in DeserializationOperationContext<TExtentionType> context, in SequenceReader<byte> source, in T obj);
-		ValueTask DeserializeToAsync(DeserializationOperationContext<TExtentionType> context, Stream streamSource, T obj);
+		void Serialize(ref SerializationOperationContext<TExtentionType> context, T obj, IBufferWriter<byte> sink);
+		ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtentionType> context, T obj, Stream streamSink);
+		T Deserialize(ref DeserializationOperationContext<TExtentionType> context, ref SequenceReader<byte> source);
+		ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext<TExtentionType> context, Stream streamSource);
+		bool DeserializeTo(ref DeserializationOperationContext<TExtentionType> context, ref SequenceReader<byte> source, in T obj);
+		ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtentionType> context, Stream streamSource, T obj);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude b/src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude
new file mode 100644
index 000000000..5cdba01ee
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude
@@ -0,0 +1,111 @@
+<#+
+void WriteContext(bool isSerialization, bool isAsync)
+{
+	var typeClass = isAsync ? "sealed class" : "struct";
+	var typePrefix = isSerialization ? "Serialization" : "Deserialization";
+	var typeName = $"{(isAsync ? "Async" : String.Empty)}{typePrefix}OperationContext";
+	var optionTypeName = $"{typePrefix}Options";
+	var primitive = isSerialization ? "Encoder" : "Decoder";
+#>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+<#+
+if (!isSerialization)
+{
+#>
+using System.Buffers;
+<#+
+}
+#>
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	public <#= typeClass #> <#= typeName #><TExtensionType>
+	{
+		public <#= primitive #><TExtensionType> <#= primitive #> { get; }
+		public <#= optionTypeName #> Options { get; }
+		public Encoding? StringEncoding => this.Options.StringEncoding;
+<#+
+	if (!isSerialization)
+	{
+#>
+		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
+<#+
+	}
+#>
+		public int CurrentDepth { get; private set; }
+		public CancellationToken CancellationToken { get; }
+
+		public <#= typeName #>(<#= primitive #><TExtensionType> <#= primitive.ToLowerInvariant() #>, <#= optionTypeName #>? options, CancellationToken cancellationToken)
+		{
+			this.<#= primitive #> = Ensure.NotNull(<#= primitive.ToLowerInvariant() #>);
+			this.Options = options ?? <#= optionTypeName #>.Default;
+			this.CurrentDepth = 0;
+			this.CancellationToken = cancellationToken;
+		}
+
+<#+
+	if (isAsync)
+	{
+		var syncTypeName = typeName.Substring("Async".Length);
+#>
+		public <#= syncTypeName #><TExtensionType> As<#= syncTypeName #>()
+			=> new <#= syncTypeName #><TExtensionType>(this.<#= primitive #>, this.Options, this.CancellationToken);
+
+<#+
+	}
+#>
+		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
+
+		public int IncrementDepth()
+		{
+			if (this.CurrentDepth == this.Options.MaxDepth)
+			{
+				Throw.DepthExeeded(this.CurrentDepth, this.Options.MaxDepth);
+			}
+
+			return this.CurrentDepth++;
+		}
+
+		public int DecrementDepth()
+		{
+			if (this.CurrentDepth == 0)
+			{
+				Throw.DepthUnderflow();
+			}
+
+			return this.CurrentDepth--;
+		}
+<#+
+	if (!isSerialization)
+	{
+		var qualifier = isAsync ? String.Empty : "readonly ";
+#>
+
+		public <#= qualifier #>void ValidatePropertyKeyLength(long position, int length)
+		{
+			if(length > this.Options.MaxPropertyKeyLength)
+			{
+				Throw.TooLargePropertyKey(position, length, this.Options.MaxPropertyKeyLength);
+			}
+		}
+<#+
+	}
+#>
+	}
+}
+<#+
+}
+#>
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
index ef6167fc4..b1f829e15 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
@@ -2,6 +2,12 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
 using System;
 using System.Text;
 using System.Threading;
@@ -13,39 +19,38 @@ public struct SerializationOperationContext<TExtensionType>
 	{
 		public Encoder<TExtensionType> Encoder { get; }
 		public SerializationOptions Options { get; }
-		private int _currentDepth;
-		public int CurrentDepth => this._currentDepth;
-		public CancellationToken CancellationToken { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public int CurrentDepth { get; private set; }
+		public CancellationToken CancellationToken { get; }
 
 		public SerializationOperationContext(Encoder<TExtensionType> encoder, SerializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Encoder = Ensure.NotNull(encoder);
 			this.Options = options ?? SerializationOptions.Default;
-			this._currentDepth = 0;
+			this.CurrentDepth = 0;
 			this.CancellationToken = cancellationToken;
 		}
 
-		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this._currentDepth);
+		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
 
 		public int IncrementDepth()
 		{
-			if (this._currentDepth == this.Options.MaxDepth)
+			if (this.CurrentDepth == this.Options.MaxDepth)
 			{
-				Throw.DepthExeeded(this._currentDepth, this.Options.MaxDepth);
+				Throw.DepthExeeded(this.CurrentDepth, this.Options.MaxDepth);
 			}
 
-			return this._currentDepth++;
+			return this.CurrentDepth++;
 		}
 
 		public int DecrementDepth()
 		{
-			if (this._currentDepth == 0)
+			if (this.CurrentDepth == 0)
 			{
 				Throw.DepthUnderflow();
 			}
 
-			return this._currentDepth--;
+			return this.CurrentDepth--;
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.tt
new file mode 100644
index 000000000..f04ef1652
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.tt
@@ -0,0 +1,6 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./OperationContext.ttinclude" #>
+<#@ output extension=".cs" #>
+<#
+WriteContext(isSerialization: true, isAsync: false);
+#>
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
index 8016eeece..90ef1bd8a 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
@@ -8,7 +8,7 @@ namespace MsgPack.Serialization
 {
 	public sealed class SerializationOptionsBuilder
 	{
-		private int _maxDepth;
+		private int _maxDepth = OptionsDefaults.MaxDepth;
 
 		public int MaxDepth
 		{
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
index 0a5628fab..07abafe57 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
+++ b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
@@ -38,74 +38,92 @@ DeserializationOptions deserializationOptions
 		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext<TExtentionType> context)
 			=> context = new SerializationOperationContext<TExtentionType>(this._encoderFactory(), this._serializationOptions, cancellationToken);
 
+		private void InitializeAsyncSerializationOperationContext(CancellationToken cancellationToken, out AsyncSerializationOperationContext<TExtentionType> context)
+			=> context = new AsyncSerializationOperationContext<TExtentionType>(this._encoderFactory(), this._serializationOptions, cancellationToken);
+
 		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext<TExtentionType> context)
 			=> context = new DeserializationOperationContext<TExtentionType>(this._decoderFactory(), this._deserializationOptions, cancellationToken);
 
+		private void InitializeAsyncDeserializationOperationContext(CancellationToken cancellationToken, out AsyncDeserializationOperationContext<TExtentionType> context)
+			=> context = new AsyncDeserializationOperationContext<TExtentionType>(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+
 		public void Serialize(T obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default)
 		{
 			this.InitializeSerializationOperationContext(cancellationToken, out var context);
-			this._underlying.Serialize(context, obj, sink);
+			this._underlying.Serialize(ref context, obj, sink);
 		}
 
 		public ReadOnlyMemory<byte> Serialize(T obj, CancellationToken cancellationToken = default)
 		{
 			this.InitializeSerializationOperationContext(cancellationToken, out var context);
 			var writer = new ArrayBufferWriter<byte>();
-			this._underlying.Serialize(context, obj, writer);
+			this._underlying.Serialize(ref context, obj, writer);
 			return writer.WrittenMemory;
 		}
 
 		public ValueTask SerializeAsync(T obj, Stream streamSink, CancellationToken cancellationToken = default)
 		{
-			this.InitializeSerializationOperationContext(cancellationToken, out var context);
+			this.InitializeAsyncSerializationOperationContext(cancellationToken, out var context);
 			return this._underlying.SerializeAsync(context, obj, streamSink);
 		}
 
-		public T Deserialize(in SequenceReader<byte> reader, CancellationToken cancellationToken = default)
+		public T Deserialize(ref SequenceReader<byte> reader, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.Deserialize(context, reader);
+			return this._underlying.Deserialize(ref context, ref reader);
 		}
 
-		public T Deserialize(in ReadOnlySequence<byte> source, CancellationToken cancellationToken = default)
+		public T Deserialize(ref ReadOnlySequence<byte> source, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.Deserialize(context, new SequenceReader<byte>(source));
+			var reader = new SequenceReader<byte>(source);
+			var result = this._underlying.Deserialize(ref context, ref reader);
+			source = source.Slice(source.Start, reader.Position);
+			return result;
 		}
 
-		public T Deserialize(ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default)
+		public T Deserialize(ref ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.Deserialize(context, new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource)));
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource));
+			var result = this._underlying.Deserialize(ref context, ref reader);
+			memorySource = memorySource.Slice((int)reader.Consumed);
+			return result;
 		}
 
 		public ValueTask<T> DeserializeAsync(Stream streamSource, CancellationToken cancellationToken = default)
 		{
-			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			this.InitializeAsyncDeserializationOperationContext(cancellationToken, out var context);
 			return this._underlying.DeserializeAsync(context, streamSource);
 		}
 
-		public void DeserializeTo(in SequenceReader<byte> reader, T obj, CancellationToken cancellationToken = default)
+		public bool DeserializeTo(ref SequenceReader<byte> reader, T obj, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			this._underlying.DeserializeTo(context, reader, obj);
+			return this._underlying.DeserializeTo(ref context, ref reader, obj);
 		}
 
-		public void DeserializeTo(in ReadOnlySequence<byte> source, T obj, CancellationToken cancellationToken = default)
+		public bool DeserializeTo(ref ReadOnlySequence<byte> source, T obj, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			this._underlying.DeserializeTo(context, new SequenceReader<byte>(source), obj);
+			var reader = new SequenceReader<byte>(source);
+			var result = this._underlying.DeserializeTo(ref context, ref reader, obj);
+			source = source.Slice(source.Start, reader.Position);
+			return result;
 		}
 
-		public void DeserializeTo(ReadOnlyMemory<byte> memorySource, T obj, CancellationToken cancellationToken = default)
+		public bool DeserializeTo(ref ReadOnlyMemory<byte> memorySource, T obj, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			this._underlying.DeserializeTo(context, new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource)), obj);
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource));
+			var result = this._underlying.DeserializeTo(ref context, ref reader, obj);
+			memorySource = memorySource.Slice((int)reader.Consumed);
+			return result;
 		}
 
-		public ValueTask DeserializeToAsync(Stream streamSource, T obj, CancellationToken cancellationToken = default)
+		public ValueTask<bool> DeserializeToAsync(Stream streamSource, T obj, CancellationToken cancellationToken = default)
 		{
-			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
+			this.InitializeAsyncDeserializationOperationContext(cancellationToken, out var context);
 			return this._underlying.DeserializeToAsync(context, streamSource, obj);
 		}
 	}
diff --git a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
index b8183564b..a41c8c45e 100644
--- a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
@@ -14,9 +14,18 @@ namespace MsgPack.Internal
 	/// </summary>
 	internal sealed class CurrentMessagePackEncoder : MessagePackEncoder
 	{
+		private static readonly CurrentMessagePackEncoder DefaultInstance = new CurrentMessagePackEncoder(MessagePackEncoderOptions.Default);
+
 		public CurrentMessagePackEncoder(MessagePackEncoderOptions options)
 			: base(options) { }
 
+		internal static byte[] InternalEncodeString(string value)
+		{
+			var arrayBuffer = new ArrayBufferWriter<byte>();
+			DefaultInstance.EncodeString(value, arrayBuffer);
+			return arrayBuffer.WrittenMemory.ToArray();
+		}
+
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		protected sealed override int EncodeStringHeader(uint length, Span<byte> buffer)
 		{
@@ -27,20 +36,20 @@ protected sealed override int EncodeStringHeader(uint length, Span<byte> buffer)
 			}
 			else if (length <= Byte.MaxValue)
 			{
-				buffer[1] = unchecked((byte)length);
 				buffer[0] = MessagePackCode.Str8;
+				buffer[1] = unchecked((byte)length);
 				return 2;
 			}
 			else if (length <= UInt16.MaxValue)
 			{
 				buffer[0] = MessagePackCode.Str16;
-				BinaryPrimitives.WriteUInt16BigEndian(buffer, unchecked((ushort)length));
+				BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), unchecked((ushort)length));
 				return sizeof(ushort) + 1;
 			}
 			else
 			{
 				buffer[0] = MessagePackCode.Str32;
-				BinaryPrimitives.WriteUInt32BigEndian(buffer, length);
+				BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), length);
 				return sizeof(uint) + 1;
 			}
 		}
@@ -50,20 +59,20 @@ protected sealed override int EncodeBinaryHeader(uint length, Span<byte> buffer)
 		{
 			if (length <= Byte.MaxValue)
 			{
-				buffer[1] = unchecked((byte)length);
 				buffer[0] = MessagePackCode.Bin8;
+				buffer[1] = unchecked((byte)length);
 				return 2;
 			}
 			else if (length <= UInt16.MaxValue)
 			{
 				buffer[0] = MessagePackCode.Bin16;
-				BinaryPrimitives.WriteUInt16BigEndian(buffer, unchecked((ushort)length));
+				BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), unchecked((ushort)length));
 				return sizeof(ushort) + 1;
 			}
 			else
 			{
 				buffer[0] = MessagePackCode.Bin32;
-				BinaryPrimitives.WriteUInt32BigEndian(buffer, length);
+				BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), length);
 				return sizeof(uint) + 1;
 			}
 		}
diff --git a/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs b/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs
index f0d39367e..eb5f16bc0 100644
--- a/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/LegacyMessagePackEncoder.cs
@@ -3,6 +3,7 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+using System.Buffers;
 using System.Buffers.Binary;
 using System.Runtime.CompilerServices;
 
@@ -13,9 +14,18 @@ namespace MsgPack.Internal
 	/// </summary>
 	internal sealed class LegacyMessagePackEncoder : MessagePackEncoder
 	{
+		private static readonly LegacyMessagePackEncoder DefaultInstance = new LegacyMessagePackEncoder(MessagePackEncoderOptions.Default);
+
 		public LegacyMessagePackEncoder(MessagePackEncoderOptions options)
 			: base(options) { }
 
+		internal static byte[] InternalEncodeString(string value)
+		{
+			var arrayBuffer = new ArrayBufferWriter<byte>();
+			DefaultInstance.EncodeString(value, arrayBuffer);
+			return arrayBuffer.WrittenMemory.ToArray();
+		}
+
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		protected sealed override int EncodeStringHeader(uint length, Span<byte> buffer)
 		{
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
index 5f8d6ca3f..e2f6bf09a 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
@@ -9,82 +9,85 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		public sealed override CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount, out int requestHint)
+		public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount, out int requestHint)
 		{
-			var consumed = 0L;
-			var result = this.PrivateDecodeArrayOrMapHeader(source, ref consumed, out var header, out itemsCount, out requestHint);
+			var startOffset = source.Consumed;
+			var result = this.PrivateDecodeArrayOrMapHeader(ref source, out var header, out itemsCount, out requestHint);
 
 			if (itemsCount > Int32.MaxValue)
 			{
-				MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - consumed, itemsCount);
+				MessagePackThrow.TooLargeArrayOrMapLength(header, startOffset, itemsCount);
 			}
 
 			return result;
 		}
 
-		private CollectionType PrivateDecodeArrayOrMapHeader(in SequenceReader<byte> source, ref long consumed, out byte header, out long itemsCount, out int requestHint)
+		private CollectionType PrivateDecodeArrayOrMapHeader(ref SequenceReader<byte> source, out byte header, out long itemsCount, out int requestHint)
 		{
-			var result = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out header, out itemsCount, out requestHint);
+			var startOffset = source.Consumed;
+			var result = this.DecodeArrayOrMapHeaderCore(ref source, out header, out itemsCount, out requestHint);
 			if (result == CollectionType.None)
 			{
-				MessagePackThrow.TypeIsNotArrayNorMap(header, source.Consumed - consumed);
+				MessagePackThrow.TypeIsNotArrayNorMap(header, startOffset);
 			}
 
 			return result;
 		}
 
-		private CollectionType DecodeArrayOrMapHeaderCore(in SequenceReader<byte> source, ref long consumed, out byte header, out long itemsCount, out int requestHint)
+		private CollectionType DecodeArrayOrMapHeaderCore(ref SequenceReader<byte> source, out byte header, out long itemsCount, out int requestHint)
 		{
-			if (!this.TryPeek(source, out header))
+			if (!source.TryRead(out header))
 			{
 				requestHint = 1;
 				itemsCount = 0;
 				return default;
 			}
 
+			requestHint = 0;
+
+			if (header == MessagePackCode.NilValue)
+			{
+				itemsCount = 0;
+				return CollectionType.Null;
+			}
+
 			if ((header & MessagePackCode.MinimumFixedArray) == MessagePackCode.MinimumFixedArray)
 			{
 				itemsCount = (uint)header - MessagePackCode.MinimumFixedArray;
-				requestHint = 0;
-				source.Advance(1);
-				consumed++;
 				return CollectionType.Array;
 			}
 
-			if ((header & MessagePackCode.MaximumFixedMap) == MessagePackCode.MaximumFixedMap)
+			if ((header & MessagePackCode.MinimumFixedMap) == MessagePackCode.MinimumFixedMap)
 			{
-				itemsCount = (uint)header - MessagePackCode.MaximumFixedMap;
-				requestHint = 0;
-				source.Advance(1);
-				consumed++;
+				itemsCount = (uint)header - MessagePackCode.MinimumFixedMap;
 				return CollectionType.Map;
 			}
 
-			int length;
+			int lengthOfLength;
 			CollectionType type;
 			switch (header)
 			{
 				case MessagePackCode.Array16:
 				{
-					length = 3;
+					lengthOfLength = 2;
 					type = CollectionType.Array;
 					break;
 				}
 				case MessagePackCode.Array32:
 				{
-					length = 5;
+					lengthOfLength = 4;
 					type = CollectionType.Array;
 					break;
 				}
 				case MessagePackCode.Map16:
 				{
-					length = 3;
+					lengthOfLength = 2;
 					type = CollectionType.Map;
 					break;
 				}
 				case MessagePackCode.Map32:
 				{
-					length = 5;
+					lengthOfLength = 4;
 					type = CollectionType.Map;
 					break;
 				}
@@ -96,73 +99,68 @@ private CollectionType DecodeArrayOrMapHeaderCore(in SequenceReader<byte> source
 				}
 			}
 
-			var lengthOfLength = length - 1;
-
 			switch (lengthOfLength)
 			{
 				case 2:
 				{
-					itemsCount = ReadValue<ushort>(source, offset: 1, out requestHint);
+					itemsCount = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 					break;
 				}
 				default: // 4
 				{
-					itemsCount = ReadValue<uint>(source, offset: 1, out requestHint);
+					itemsCount = ReadValue<uint>(ref source, offset: 1, out requestHint);
 					break;
 				}
 			}
 
 			if (requestHint != 0)
 			{
+				source.Rewind(1);
 				return CollectionType.None;
 			}
 
-			source.Advance(length);
-			consumed += length;
 			return type;
 		}
 
-		public sealed override long DecodeArrayHeader(in SequenceReader<byte> source, out int requestHint)
+		public sealed override long DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var consumed = 0L;
-			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var itemsCount, out requestHint);
+			var startOffset = source.Consumed;
+			var type = this.DecodeArrayOrMapHeaderCore(ref source, out var header, out var itemsCount, out requestHint);
 			if (requestHint != 0)
 			{
-				source.Rewind(consumed);
 				return 0;
 			}
 
 			if (itemsCount > Int32.MaxValue)
 			{
-				MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - consumed, itemsCount);
+				MessagePackThrow.TooLargeArrayOrMapLength(header, startOffset, itemsCount);
 			}
 
-			if (!type.IsArray)
+			if (type.IsMap)
 			{
-				MessagePackThrow.TypeIsNotArray(header, source.Consumed - consumed);
+				MessagePackThrow.TypeIsNotArray(header, startOffset);
 			}
 
 			return (int)itemsCount;
 		}
 
-		public sealed override long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint)
+		public sealed override long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var consumed = 0L;
-			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var itemsCount, out requestHint);
+			var startOffset = source.Consumed;
+			var type = this.DecodeArrayOrMapHeaderCore(ref source, out var header, out var itemsCount, out requestHint);
 			if (requestHint != 0)
 			{
-				source.Rewind(consumed);
 				return 0;
 			}
 
 			if (itemsCount > Int32.MaxValue)
 			{
-				MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - consumed, itemsCount);
+				MessagePackThrow.TooLargeArrayOrMapLength(header, startOffset, itemsCount);
 			}
 
-			if (!type.IsMap)
+			if (type.IsArray)
 			{
-				MessagePackThrow.TypeIsNotMap(header, source.Consumed - consumed);
+				MessagePackThrow.TypeIsNotMap(header, startOffset);
 			}
 
 			return (int)itemsCount;
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
index b5950552a..71c6ac50d 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
@@ -12,9 +12,9 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		public sealed override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemResult<MessagePackExtensionType> result, CancellationToken cancellationToken = default)
+		public sealed override bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult<MessagePackExtensionType> result, CancellationToken cancellationToken = default)
 		{
-			var elementType = this.ReadHeader(source, out var consumed, out var valueOrLength, out var requestHint);
+			var elementType = this.ReadHeader(ref source, out var consumed, out var valueOrLength, out var requestHint);
 			if (requestHint != 0)
 			{
 				result = DecodeItemResult<MessagePackExtensionType>.InsufficientInput(requestHint);
@@ -52,7 +52,7 @@ public sealed override bool DecodeItem(in SequenceReader<byte> source, out Decod
 				case ElementType.Array:
 				case ElementType.Map:
 				{
-					this.DecodeArrayOrMap(source, out var iterator);
+					this.DecodeArrayOrMap(ref source, out var iterator);
 					result = DecodeItemResult<MessagePackExtensionType>.CollectionHeader(elementType, this.CreateIterator((uint)valueOrLength), valueOrLength);
 					break;
 				}
@@ -78,7 +78,7 @@ public sealed override bool DecodeItem(in SequenceReader<byte> source, out Decod
 						return false;
 					}
 
-					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, source.Sequence.Slice(source.Consumed + consumed, valueOrLength));
+					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, source.Sequence.Slice(source.Position).Slice(consumed, valueOrLength));
 					consumed += valueOrLength;
 					break;
 				}
@@ -95,7 +95,7 @@ public sealed override bool DecodeItem(in SequenceReader<byte> source, out Decod
 						return false;
 					}
 
-					var extensionSlice = source.Sequence.Slice(source.Consumed + consumed - 1);
+					var extensionSlice = source.Sequence.Slice(source.Position).Slice(consumed - 1);
 					var typeCode = new MessagePackExtensionType(extensionSlice.FirstSpan[0]);
 					var body = extensionSlice.Slice(1, valueOrLength);
 
@@ -109,9 +109,9 @@ public sealed override bool DecodeItem(in SequenceReader<byte> source, out Decod
 			return true;
 		}
 
-		private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed, out long valueOrLength, out int requestHint)
+		private ElementType ReadHeader(ref SequenceReader<byte> source, out long consumed, out long valueOrLength, out int requestHint)
 		{
-			if (!this.TryPeek(source, out var header))
+			if (!source.TryPeek(out var header))
 			{
 				requestHint = 1;
 				valueOrLength = default;
@@ -154,70 +154,70 @@ private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed
 				{
 					case MessagePackCode.SignedInt8:
 					{
-						valueOrLength = ReadSByte(source, offset: 1, out requestHint);
+						valueOrLength = ReadSByte(ref source, offset: 1, out requestHint);
 						consumed += sizeof(sbyte);
 						result = ElementType.Int32;
 						break;
 					}
 					case MessagePackCode.SignedInt16:
 					{
-						valueOrLength = ReadValue<short>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<short>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(short);
 						result = ElementType.Int32;
 						break;
 					}
 					case MessagePackCode.SignedInt32:
 					{
-						valueOrLength = ReadValue<int>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<int>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(int);
 						result = ElementType.Int32;
 						break;
 					}
 					case MessagePackCode.SignedInt64:
 					{
-						valueOrLength = ReadValue<long>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<long>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(long);
 						result = ElementType.Int64;
 						break;
 					}
 					case MessagePackCode.UnsignedInt8:
 					{
-						valueOrLength = ReadByte(source, offset: 1, out requestHint);
+						valueOrLength = ReadByte(ref source, offset: 1, out requestHint);
 						consumed += sizeof(byte);
 						result = ElementType.Int32;
 						break;
 					}
 					case MessagePackCode.UnsignedInt16:
 					{
-						valueOrLength = ReadValue<ushort>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(ushort);
 						result = ElementType.Int32;
 						break;
 					}
 					case MessagePackCode.UnsignedInt32:
 					{
-						valueOrLength = ReadValue<uint>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<uint>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(uint);
 						result = ElementType.Int64;
 						break;
 					}
 					case MessagePackCode.UnsignedInt64:
 					{
-						valueOrLength = unchecked((long)ReadValue<ulong>(source, offset: 1, out requestHint));
+						valueOrLength = unchecked((long)ReadValue<ulong>(ref source, offset: 1, out requestHint));
 						consumed += sizeof(ulong);
 						result = ElementType.UInt64;
 						break;
 					}
 					case MessagePackCode.Real32:
 					{
-						valueOrLength = ReadValue<int>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<int>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(int);
 						result = ElementType.Single;
 						break;
 					}
 					case MessagePackCode.Real64:
 					{
-						valueOrLength = ReadValue<long>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<long>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(long);
 						result = ElementType.Double;
 						break;
@@ -242,28 +242,28 @@ private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed
 					}
 					case MessagePackCode.Array16:
 					{
-						valueOrLength = ReadValue<ushort>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(ushort);
 						result = ElementType.Array;
 						break;
 					}
 					case MessagePackCode.Array32:
 					{
-						valueOrLength = ReadValue<uint>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<uint>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(uint);
 						result = ElementType.Array;
 						break;
 					}
 					case MessagePackCode.Map16:
 					{
-						valueOrLength = ReadValue<ushort>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(ushort);
 						result = ElementType.Map;
 						break;
 					}
 					case MessagePackCode.Map32:
 					{
-						valueOrLength = ReadValue<uint>(source, offset: 1, out requestHint);
+						valueOrLength = ReadValue<uint>(ref source, offset: 1, out requestHint);
 						consumed += sizeof(uint);
 						result = ElementType.Map;
 						break;
@@ -277,7 +277,7 @@ private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed
 					case MessagePackCode.Ext16:
 					case MessagePackCode.Ext32:
 					{
-						result = ReadExtentionItem(header, source, offset: 1, ref consumed, out valueOrLength, out requestHint);
+						result = ReadExtentionItem(header, ref source, offset: 1, ref consumed, out valueOrLength, out requestHint);
 						break;
 					}
 					default:
@@ -293,7 +293,7 @@ private ElementType ReadHeader(in SequenceReader<byte> source, out long consumed
 			return result;
 		}
 
-		private static ElementType ReadExtentionItem(byte header, SequenceReader<byte> source, int offset, ref long consumed, out long valueOrLength, out int requestHint)
+		private static ElementType ReadExtentionItem(byte header, ref SequenceReader<byte> source, int offset, ref long consumed, out long valueOrLength, out int requestHint)
 		{
 			consumed++;
 			requestHint = 0;
@@ -327,7 +327,7 @@ private static ElementType ReadExtentionItem(byte header, SequenceReader<byte> s
 				}
 				default:
 				{
-					_ = ReadByte(source, offset, out requestHint);
+					_ = ReadByte(ref source, offset, out requestHint);
 					if (requestHint != 0)
 					{
 						valueOrLength = default;
@@ -341,20 +341,20 @@ private static ElementType ReadExtentionItem(byte header, SequenceReader<byte> s
 					{
 						case MessagePackCode.Ext8:
 						{
-							valueOrLength = ReadByte(source, offset, out requestHint);
+							valueOrLength = ReadByte(ref source, offset, out requestHint);
 							consumed++;
 							break;
 						}
 						case MessagePackCode.Ext16:
 						{
-							valueOrLength = ReadValue<ushort>(source, offset, out requestHint);
+							valueOrLength = ReadValue<ushort>(ref source, offset, out requestHint);
 							consumed += sizeof(ushort);
 							break;
 						}
 						default:
 						{
 							Debug.Assert(header == MessagePackCode.Ext32, $"header(0x{header:X2}) == MessagePackCode.Ext32(0x{MessagePackCode.Ext32:X2})");
-							valueOrLength = ReadValue<uint>(source, offset + 1, out requestHint);
+							valueOrLength = ReadValue<uint>(ref source, offset + 1, out requestHint);
 							consumed += sizeof(uint);
 							break;
 						}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
index de25b0528..603775c8c 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
@@ -11,9 +11,9 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		private uint ReadExtensionHeader(in SequenceReader<byte> source, out int consumed, out int requestHint)
+		private uint ReadExtensionHeader(ref SequenceReader<byte> source, out int consumed, out int requestHint)
 		{
-			if(!this.TryPeek(source, out var header))
+			if(!source.TryPeek(out var header))
 			{
 				consumed = 0;
 				requestHint = 1;
@@ -79,18 +79,18 @@ private uint ReadExtensionHeader(in SequenceReader<byte> source, out int consume
 			{
 				case 1:
 				{
-					length = ReadByte(source, offset: 1, out requestHint);
+					length = ReadByte(ref source, offset: 1, out requestHint);
 					break;
 				}
 				case 2:
 				{
-					length = ReadValue<ushort>(source, offset: 1, out requestHint);
+					length = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 					break;
 				}
 				default:
 				{
 					Debug.Assert(lengthOflength == 4, $"length({lengthOflength}) == 4");
-					length = ReadValue<uint>(source, offset: 1, out requestHint);
+					length = ReadValue<uint>(ref source, offset: 1, out requestHint);
 					break;
 				}
 			}
@@ -104,9 +104,9 @@ private uint ReadExtensionHeader(in SequenceReader<byte> source, out int consume
 			return length;
 		}
 
-		public override void DecodeExtension(in SequenceReader<byte> source, out MessagePackExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		public override void DecodeExtension(ref SequenceReader<byte> source, out MessagePackExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			var bodyLength = this.ReadExtensionHeader(source, out var consumed, out requestHint);
+			var bodyLength = this.ReadExtensionHeader(ref source, out var consumed, out requestHint);
 			if (requestHint != 0)
 			{
 				typeCode = default;
@@ -114,7 +114,7 @@ public override void DecodeExtension(in SequenceReader<byte> source, out Message
 				return;
 			}
 
-			if (!this.TryPeek(source, out byte typeCodeByte))
+			if (!source.TryPeek(out byte typeCodeByte))
 			{
 				requestHint = 1;
 				typeCode = default;
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs
index 1708f0b05..ff2a60e40 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.cs
@@ -17,9 +17,9 @@ partial class MessagePackDecoder
 	{
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override SByte DecodeSByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override SByte DecodeSByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeSignedInteger(source, typeof(SByte), out var header, out var result, out requestHint))
+			if (!this.TryDecodeSignedInteger(ref source, typeof(SByte), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -33,9 +33,9 @@ public sealed override SByte DecodeSByte(in SequenceReader<byte> source, out int
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int16 DecodeInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int16 DecodeInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeSignedInteger(source, typeof(Int16), out var header, out var result, out requestHint))
+			if (!this.TryDecodeSignedInteger(ref source, typeof(Int16), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -49,9 +49,9 @@ public sealed override Int16 DecodeInt16(in SequenceReader<byte> source, out int
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int32 DecodeInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int32 DecodeInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeSignedInteger(source, typeof(Int32), out var header, out var result, out requestHint))
+			if (!this.TryDecodeSignedInteger(ref source, typeof(Int32), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -65,9 +65,9 @@ public sealed override Int32 DecodeInt32(in SequenceReader<byte> source, out int
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int64 DecodeInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int64 DecodeInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeSignedInteger(source, typeof(Int64), out var header, out var result, out requestHint))
+			if (!this.TryDecodeSignedInteger(ref source, typeof(Int64), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -76,9 +76,9 @@ public sealed override Int64 DecodeInt64(in SequenceReader<byte> source, out int
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Byte DecodeByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Byte DecodeByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeUnsignedInteger(source, typeof(Byte), out var header, out var result, out requestHint))
+			if (!this.TryDecodeUnsignedInteger(ref source, typeof(Byte), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -92,9 +92,9 @@ public sealed override Byte DecodeByte(in SequenceReader<byte> source, out int r
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt16 DecodeUInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt16 DecodeUInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeUnsignedInteger(source, typeof(UInt16), out var header, out var result, out requestHint))
+			if (!this.TryDecodeUnsignedInteger(ref source, typeof(UInt16), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -108,9 +108,9 @@ public sealed override UInt16 DecodeUInt16(in SequenceReader<byte> source, out i
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt32 DecodeUInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt32 DecodeUInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeUnsignedInteger(source, typeof(UInt32), out var header, out var result, out requestHint))
+			if (!this.TryDecodeUnsignedInteger(ref source, typeof(UInt32), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
@@ -124,19 +124,19 @@ public sealed override UInt32 DecodeUInt32(in SequenceReader<byte> source, out i
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt64 DecodeUInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt64 DecodeUInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryDecodeUnsignedInteger(source, typeof(UInt64), out var header, out var result, out requestHint))
+			if (!this.TryDecodeUnsignedInteger(ref source, typeof(UInt64), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
 			return unchecked((UInt64)result);
 		}
 
-
-		private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, out byte header, out Int64 value, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private bool TryDecodeSignedInteger(ref SequenceReader<byte> source, Type type, out byte header, out Int64 value, out int requestHint)
 		{
-			if (!this.TryPeek(source, out header))
+			if (!source.TryPeek(out header))
 			{
 				requestHint = 1;
 				value = default;
@@ -148,16 +148,24 @@ private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, o
 			if (header < 128)
 			{
 				value = header;
+				source.Advance(1);
 				return true;
 			}
 
 			if (header >= 0xE0)
 			{
 				value = unchecked((sbyte)header);
+				source.Advance(1);
 				return true;
 			}
 
-			ParseNumberHeader(header, source, type, out var length, out var kind);
+			return this.TryDecodeSignedIntegerSlow(ref source, type, header, out value, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private bool TryDecodeSignedIntegerSlow(ref SequenceReader<byte> source, Type type, byte header, out Int64 value, out int requestHint)
+		{
+			ParseNumberHeader(header, ref source, type, out var length, out var kind);
 
 			if ((kind & NumberKind.RealBitMask) != 0 && !this.Options.CanTreatRealAsInteger)
 			{
@@ -172,23 +180,23 @@ private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, o
 					{
 						case 1:
 						{
-							value = ReadSByte(source, offset: 1, out requestHint);
+							value = ReadSByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							value = ReadValue<short>(source, offset: 1, out requestHint);
+							value = ReadValue<short>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							value = ReadValue<int>(source, offset: 1, out requestHint);
+							value = ReadValue<int>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							value = ReadValue<long>(source, offset: 1, out requestHint);
+							value = ReadValue<long>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -207,23 +215,23 @@ private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, o
 					{
 						case 1:
 						{
-							unsigned = ReadByte(source, offset: 1, out requestHint);
+							unsigned = ReadByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							unsigned = ReadValue<ushort>(source, offset: 1, out requestHint);
+							unsigned = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							unsigned = ReadValue<uint>(source, offset: 1, out requestHint);
+							unsigned = ReadValue<uint>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							unsigned = ReadValue<ulong>(source, offset: 1, out requestHint);
+							unsigned = ReadValue<ulong>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -244,7 +252,7 @@ private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, o
 				}
 				case NumberKind.Single:
 				{
-					var real = ReadValue<float>(source, offset: 1, out requestHint);
+					var real = ReadValue<float>(ref source, offset: 1, out requestHint);
 					if (requestHint != 0)
 					{
 						value = default;
@@ -267,7 +275,7 @@ private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, o
 				default:
 				{
 					Debug.Assert(kind == NumberKind.Double, $"kind({kind}) == NumberType.Double");
-					var real = ReadValue<double>(source, offset: 1, out requestHint);
+					var real = ReadValue<double>(ref source, offset: 1, out requestHint);
 					if (requestHint != 0)
 					{
 						value = default;
@@ -292,10 +300,10 @@ private bool TryDecodeSignedInteger(in SequenceReader<byte> source, Type type, o
 			return true;
 		}
 
-
-		private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type, out byte header, out UInt64 value, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private bool TryDecodeUnsignedInteger(ref SequenceReader<byte> source, Type type, out byte header, out UInt64 value, out int requestHint)
 		{
-			if (!this.TryPeek(source, out header))
+			if (!source.TryPeek(out header))
 			{
 				requestHint = 1;
 				value = default;
@@ -307,10 +315,17 @@ private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type,
 			if (header < 128)
 			{
 				value = header;
+				source.Advance(1);
 				return true;
 			}
 
-			ParseNumberHeader(header, source, type, out var length, out var kind);
+			return this.TryDecodeUnsignedIntegerSlow(ref source, type, header, out value, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private bool TryDecodeUnsignedIntegerSlow(ref SequenceReader<byte> source, Type type, byte header, out UInt64 value, out int requestHint)
+		{
+			ParseNumberHeader(header, ref source, type, out var length, out var kind);
 
 			if ((kind & NumberKind.RealBitMask) != 0 && !this.Options.CanTreatRealAsInteger)
 			{
@@ -326,23 +341,23 @@ private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type,
 					{
 						case 1:
 						{
-							signed = ReadSByte(source, offset: 1, out requestHint);
+							signed = ReadSByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							signed = ReadValue<short>(source, offset: 1, out requestHint);
+							signed = ReadValue<short>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							signed = ReadValue<int>(source, offset: 1, out requestHint);
+							signed = ReadValue<int>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							signed = ReadValue<long>(source, offset: 1, out requestHint);
+							signed = ReadValue<long>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -367,23 +382,23 @@ private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type,
 					{
 						case 1:
 						{
-							value = ReadByte(source, offset: 1, out requestHint);
+							value = ReadByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							value = ReadValue<ushort>(source, offset: 1, out requestHint);
+							value = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							value = ReadValue<uint>(source, offset: 1, out requestHint);
+							value = ReadValue<uint>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							value = ReadValue<ulong>(source, offset: 1, out requestHint);
+							value = ReadValue<ulong>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -397,7 +412,7 @@ private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type,
 				}
 				case NumberKind.Single:
 				{
-					var real = ReadValue<float>(source, offset: 1, out requestHint);
+					var real = ReadValue<float>(ref source, offset: 1, out requestHint);
 					if (requestHint != 0)
 					{
 						value = default;
@@ -420,7 +435,7 @@ private bool TryDecodeUnsignedInteger(in SequenceReader<byte> source, Type type,
 				default:
 				{
 					Debug.Assert(kind == NumberKind.Double, $"kind({kind}) == NumberType.Double");
-					var real = ReadValue<double>(source, offset: 1, out requestHint);
+					var real = ReadValue<double>(ref source, offset: 1, out requestHint);
 					if (requestHint != 0)
 					{
 						value = default;
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt
index 898d74a57..329a60b0c 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Integers.tt
@@ -57,10 +57,10 @@ foreach (var isSigned in new [] { true, false })
 	var methodName = $"TryDecode{(isSigned ? "Signed" : "Unsigned")}Integer";
 	var outType = isSigned ? "Int64": "UInt64";
 #>
-
-		private bool <#= methodName #>(in SequenceReader<byte> source, Type type, out byte header, out <#= outType #> value, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private bool <#= methodName #>(ref SequenceReader<byte> source, Type type, out byte header, out <#= outType #> value, out int requestHint)
 		{
-			if (!this.TryPeek(source, out header))
+			if (!source.TryPeek(out header))
 			{
 				requestHint = 1;
 				value = default;
@@ -72,6 +72,7 @@ foreach (var isSigned in new [] { true, false })
 			if (header < 128)
 			{
 				value = header;
+				source.Advance(1);
 				return true;
 			}
 
@@ -82,13 +83,20 @@ foreach (var isSigned in new [] { true, false })
 			if (header >= 0xE0)
 			{
 				value = unchecked((sbyte)header);
+				source.Advance(1);
 				return true;
 			}
 
 <#
 	} // if (isSigned)
 #>
-			ParseNumberHeader(header, source, type, out var length, out var kind);
+			return this.<#= methodName #>Slow(ref source, type, header, out value, out requestHint);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private bool <#= methodName #>Slow(ref SequenceReader<byte> source, Type type, byte header, out <#= outType #> value, out int requestHint)
+		{
+			ParseNumberHeader(header, ref source, type, out var length, out var kind);
 
 			if ((kind & NumberKind.RealBitMask) != 0 && !this.Options.CanTreatRealAsInteger)
 			{
@@ -175,7 +183,7 @@ foreach (var isSigned in new [] { true, false })
 				}
 				case NumberKind.Single:
 				{
-					var real = ReadValue<float>(source, offset: 1, out requestHint);
+					var real = ReadValue<float>(ref source, offset: 1, out requestHint);
 					if (requestHint != 0)
 					{
 						value = default;
@@ -198,7 +206,7 @@ foreach (var isSigned in new [] { true, false })
 				default:
 				{
 					Debug.Assert(kind == NumberKind.Double, $"kind({kind}) == NumberType.Double");
-					var real = ReadValue<double>(source, offset: 1, out requestHint);
+					var real = ReadValue<double>(ref source, offset: 1, out requestHint);
 					if (requestHint != 0)
 					{
 						value = default;
@@ -236,9 +244,9 @@ void WriteMethod(string type, bool isSigned, bool is64Bit)
 #>
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override <#= type #> Decode<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		public sealed override <#= type #> Decode<#= type #>(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.<#= coreMethod #>(source, typeof(<#= type #>), out var header, out var result, out requestHint))
+			if (!this.<#= coreMethod #>(ref source, typeof(<#= type #>), out var header, out var result, out requestHint))
 			{
 				return default;
 			}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs
index 3dbb8f0b1..cb5fc938d 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Iteration.cs
@@ -12,7 +12,7 @@ public partial class MessagePackDecoder
 
 		// This is instance method now because CLR/CoreCLR delegates are optmized for instance method invocation.
 		// This method might be changed static if C# supports function pointer.
-		private bool DetectCollectionEnds(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
+		private bool DetectCollectionEnds(ref SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
 		{
 			requestHint = 0;
 
@@ -25,10 +25,9 @@ private bool DetectCollectionEnds(in SequenceReader<byte> source, ref long nextI
 			return true;
 		}
 
-		public override CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint)
+		public override CollectionType DecodeArrayOrMap(ref SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint)
 		{
-			var consumed = 0L;
-			var type = this.PrivateDecodeArrayOrMapHeader(source, ref consumed, out _, out var itemsCount, out requestHint);
+			var type = this.PrivateDecodeArrayOrMapHeader(ref source, out _, out var itemsCount, out requestHint);
 			if (requestHint != 0)
 			{
 				iterator = default;
@@ -42,9 +41,9 @@ public override CollectionType DecodeArrayOrMap(in SequenceReader<byte> source,
 		private CollectionItemIterator CreateIterator(long itemsCount)
 			=> new CollectionItemIterator(this._detectCollectionEnds, itemsCount);
 
-		public override CollectionItemIterator DecodeArray(in SequenceReader<byte> source, out int requestHint)
+		public override CollectionItemIterator DecodeArray(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var itemsCount = this.DecodeArrayHeader(source, out requestHint);
+			var itemsCount = this.DecodeArrayHeader(ref source, out requestHint);
 			if (requestHint != 0)
 			{
 				return default;
@@ -53,9 +52,9 @@ public override CollectionItemIterator DecodeArray(in SequenceReader<byte> sourc
 			return new CollectionItemIterator(this._detectCollectionEnds, itemsCount);
 		}
 
-		public override CollectionItemIterator DecodeMap(in SequenceReader<byte> source, out int requestHint)
+		public override CollectionItemIterator DecodeMap(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var itemsCount = this.DecodeMapHeader(source, out requestHint);
+			var itemsCount = this.DecodeMapHeader(ref source, out requestHint);
 			if (requestHint != 0)
 			{
 				return default;
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs
index 0ca842cdc..272a67fc9 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.cs
@@ -16,145 +16,145 @@ partial class MessagePackDecoder
 	{
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Byte? DecodeNullableByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Byte? DecodeNullableByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeByte(source, out requestHint);
+			return this.DecodeByte(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override SByte? DecodeNullableSByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override SByte? DecodeNullableSByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeSByte(source, out requestHint);
+			return this.DecodeSByte(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int16? DecodeNullableInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int16? DecodeNullableInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeInt16(source, out requestHint);
+			return this.DecodeInt16(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt16? DecodeNullableUInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt16? DecodeNullableUInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeUInt16(source, out requestHint);
+			return this.DecodeUInt16(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int32? DecodeNullableInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int32? DecodeNullableInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeInt32(source, out requestHint);
+			return this.DecodeInt32(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt32? DecodeNullableUInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt32? DecodeNullableUInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeUInt32(source, out requestHint);
+			return this.DecodeUInt32(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int64? DecodeNullableInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int64? DecodeNullableInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeInt64(source, out requestHint);
+			return this.DecodeInt64(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt64? DecodeNullableUInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt64? DecodeNullableUInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeUInt64(source, out requestHint);
+			return this.DecodeUInt64(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Single? DecodeNullableSingle(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Single? DecodeNullableSingle(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeSingle(source, out requestHint);
+			return this.DecodeSingle(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Double? DecodeNullableDouble(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Double? DecodeNullableDouble(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeDouble(source, out requestHint);
+			return this.DecodeDouble(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Boolean? DecodeNullableBoolean(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Boolean? DecodeNullableBoolean(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeBoolean(source, out requestHint);
+			return this.DecodeBoolean(ref source, out requestHint);
 		}
 
 	}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt
index b73b9c7fc..5af782a13 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Nullables.tt
@@ -37,15 +37,15 @@ foreach (var type in
 #>
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override <#= type #>? DecodeNullable<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		public sealed override <#= type #>? DecodeNullable<#= type #>(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.Decode<#= type #>(source, out requestHint);
+			return this.Decode<#= type #>(ref source, out requestHint);
 		}
 
 <#
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude b/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude
index 33d1a85d5..f694f1406 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Number.ttinclude
@@ -6,23 +6,23 @@ void WriteDecodeInteger(string variable, bool isSigned)
 					{
 						case 1:
 						{
-							<#= variable #> = Read<#= isSigned ? "SByte" : "Byte" #>(source, offset: 1, out requestHint);
+							<#= variable #> = Read<#= isSigned ? "SByte" : "Byte" #>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							<#= variable #> = ReadValue<<#= isSigned ? "short" : "ushort" #>>(source, offset: 1, out requestHint);
+							<#= variable #> = ReadValue<<#= isSigned ? "short" : "ushort" #>>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							<#= variable #> = ReadValue<<#= isSigned ? "int" : "uint" #>>(source, offset: 1, out requestHint);
+							<#= variable #> = ReadValue<<#= isSigned ? "int" : "uint" #>>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							<#= variable #> = ReadValue<<#= isSigned ? "long" : "ulong" #>>(source, offset: 1, out requestHint);
+							<#= variable #> = ReadValue<<#= isSigned ? "long" : "ulong" #>>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs
index 0d5d871e7..3023f9ff2 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.cs
@@ -17,9 +17,9 @@ partial class MessagePackDecoder
 	{
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Single DecodeSingle(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Single DecodeSingle(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryPeek(source, out var header))
+			if (!source.TryPeek(out var header))
 			{
 				requestHint = 1;
 				return default;
@@ -33,7 +33,7 @@ public sealed override Single DecodeSingle(in SequenceReader<byte> source, out i
 				return header;
 			}
 
-			ParseNumberHeader(header, source, typeof(Single), out var length, out var kind);
+			ParseNumberHeader(header, ref source, typeof(Single), out var length, out var kind);
 
 			Single value;
 			switch (kind)
@@ -44,23 +44,23 @@ public sealed override Single DecodeSingle(in SequenceReader<byte> source, out i
 					{
 						case 1:
 						{
-							value = ReadSByte(source, offset: 1, out requestHint);
+							value = ReadSByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							value = ReadValue<short>(source, offset: 1, out requestHint);
+							value = ReadValue<short>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							value = ReadValue<int>(source, offset: 1, out requestHint);
+							value = ReadValue<int>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							value = ReadValue<long>(source, offset: 1, out requestHint);
+							value = ReadValue<long>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -73,23 +73,23 @@ public sealed override Single DecodeSingle(in SequenceReader<byte> source, out i
 					{
 						case 1:
 						{
-							value = ReadByte(source, offset: 1, out requestHint);
+							value = ReadByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							value = ReadValue<ushort>(source, offset: 1, out requestHint);
+							value = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							value = ReadValue<uint>(source, offset: 1, out requestHint);
+							value = ReadValue<uint>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							value = ReadValue<ulong>(source, offset: 1, out requestHint);
+							value = ReadValue<ulong>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -98,13 +98,13 @@ public sealed override Single DecodeSingle(in SequenceReader<byte> source, out i
 				}
 				case NumberKind.Single:
 				{
-					value = ReadValue<float>(source, offset: 1, out requestHint);
+					value = ReadValue<float>(ref source, offset: 1, out requestHint);
 					break;
 				}
 				default:
 				{
 					// Double
-					value = (Single)ReadValue<double>(source, offset: 1, out requestHint);
+					value = (Single)ReadValue<double>(ref source, offset: 1, out requestHint);
 					break;
 				}
 			}
@@ -119,9 +119,9 @@ public sealed override Single DecodeSingle(in SequenceReader<byte> source, out i
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Double DecodeDouble(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Double DecodeDouble(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryPeek(source, out var header))
+			if (!source.TryPeek(out var header))
 			{
 				requestHint = 1;
 				return default;
@@ -135,7 +135,7 @@ public sealed override Double DecodeDouble(in SequenceReader<byte> source, out i
 				return header;
 			}
 
-			ParseNumberHeader(header, source, typeof(Double), out var length, out var kind);
+			ParseNumberHeader(header, ref source, typeof(Double), out var length, out var kind);
 
 			Double value;
 			switch (kind)
@@ -146,23 +146,23 @@ public sealed override Double DecodeDouble(in SequenceReader<byte> source, out i
 					{
 						case 1:
 						{
-							value = ReadSByte(source, offset: 1, out requestHint);
+							value = ReadSByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							value = ReadValue<short>(source, offset: 1, out requestHint);
+							value = ReadValue<short>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							value = ReadValue<int>(source, offset: 1, out requestHint);
+							value = ReadValue<int>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							value = ReadValue<long>(source, offset: 1, out requestHint);
+							value = ReadValue<long>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -175,23 +175,23 @@ public sealed override Double DecodeDouble(in SequenceReader<byte> source, out i
 					{
 						case 1:
 						{
-							value = ReadByte(source, offset: 1, out requestHint);
+							value = ReadByte(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 2:
 						{
-							value = ReadValue<ushort>(source, offset: 1, out requestHint);
+							value = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						case 4:
 						{
-							value = ReadValue<uint>(source, offset: 1, out requestHint);
+							value = ReadValue<uint>(ref source, offset: 1, out requestHint);
 							break;
 						}
 						default: 
 						{
 							Debug.Assert(length == 8, $"length({length}) != 8");
-							value = ReadValue<ulong>(source, offset: 1, out requestHint);
+							value = ReadValue<ulong>(ref source, offset: 1, out requestHint);
 							break;
 						}
 					}
@@ -200,13 +200,13 @@ public sealed override Double DecodeDouble(in SequenceReader<byte> source, out i
 				}
 				case NumberKind.Single:
 				{
-					value = ReadValue<float>(source, offset: 1, out requestHint);
+					value = ReadValue<float>(ref source, offset: 1, out requestHint);
 					break;
 				}
 				default:
 				{
 					// Double
-					value = ReadValue<double>(source, offset: 1, out requestHint);
+					value = ReadValue<double>(ref source, offset: 1, out requestHint);
 					break;
 				}
 			}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt
index cd5e02e09..72d577988 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Reals.tt
@@ -24,9 +24,9 @@ foreach (var type in new [] { "Single", "Double" })
 #>
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override <#= type #> Decode<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		public sealed override <#= type #> Decode<#= type #>(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryPeek(source, out var header))
+			if (!source.TryPeek(out var header))
 			{
 				requestHint = 1;
 				return default;
@@ -40,7 +40,7 @@ foreach (var type in new [] { "Single", "Double" })
 				return header;
 			}
 
-			ParseNumberHeader(header, source, typeof(<#= type #>), out var length, out var kind);
+			ParseNumberHeader(header, ref source, typeof(<#= type #>), out var length, out var kind);
 
 			<#= type #> value;
 			switch (kind)
@@ -61,7 +61,7 @@ foreach (var type in new [] { "Single", "Double" })
 				}
 				case NumberKind.Single:
 				{
-					value = ReadValue<float>(source, offset: 1, out requestHint);
+					value = ReadValue<float>(ref source, offset: 1, out requestHint);
 					break;
 				}
 				default:
@@ -71,13 +71,13 @@ foreach (var type in new [] { "Single", "Double" })
 	if (type != "Double")
 	{
 #>
-					value = (<#= type #>)ReadValue<double>(source, offset: 1, out requestHint);
+					value = (<#= type #>)ReadValue<double>(ref source, offset: 1, out requestHint);
 <#
 	}
 	else
 	{
 #>
-					value = ReadValue<double>(source, offset: 1, out requestHint);
+					value = ReadValue<double>(ref source, offset: 1, out requestHint);
 <#
 	}
 #>
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs
index 2f343f721..6337cec11 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.SkipDrain.cs
@@ -11,20 +11,23 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		public sealed override void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default)
-			=> this.Drain(source, collectionContext, itemsCount: 1, out requestHint, cancellationToken);
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void Skip(ref SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default)
+			=> this.Drain(ref source, collectionContext, itemsCount: 1, out requestHint, cancellationToken);
 
-		public override void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default)
+#warning TODO: Remove ref consumed
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void Drain(ref SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			var consumed = 0L;
-			if (!this.SkipItems(source, collectionContext, itemsCount, ref consumed, out requestHint, cancellationToken))
+			if (!this.SkipItems(ref source, collectionContext, itemsCount, ref consumed, out requestHint, cancellationToken))
 			{
 				source.Rewind(consumed);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static bool SkipLength(in SequenceReader<byte> source, long length, ref long consumed, out int requestHint)
+		private static bool SkipLength(ref SequenceReader<byte> source, long length, ref long consumed, out int requestHint)
 		{
 			if (source.Remaining < length)
 			{
@@ -38,12 +41,12 @@ private static bool SkipLength(in SequenceReader<byte> source, long length, ref
 			return true;
 		}
 
-		private bool SkipArray(in SequenceReader<byte> source, in CollectionContext collectionContext, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
+		private bool SkipArray(ref SequenceReader<byte> source, in CollectionContext collectionContext, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			collectionContext.IncrementDepth();
 
 			var initialConsumed = consumed;
-			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var arrayLength, out requestHint);
+			var type = this.DecodeArrayOrMapHeaderCore(ref source, out var header, out var arrayLength, out requestHint);
 			if (requestHint != 0)
 			{
 				return false;
@@ -51,10 +54,12 @@ private bool SkipArray(in SequenceReader<byte> source, in CollectionContext coll
 
 			if (!type.IsArray)
 			{
-				MessagePackThrow.TypeIsNotArray(header, source.Consumed - consumed + initialConsumed);
+				MessagePackThrow.TypeIsNotArray(header, initialConsumed);
 			}
 
-			if (!this.SkipItems(source, collectionContext, arrayLength, ref consumed, out requestHint, cancellationToken))
+			consumed = source.Consumed - initialConsumed;
+
+			if (!this.SkipItems(ref source, collectionContext, arrayLength, ref consumed, out requestHint, cancellationToken))
 			{
 				return false;
 			}
@@ -63,12 +68,12 @@ private bool SkipArray(in SequenceReader<byte> source, in CollectionContext coll
 			return true;
 		}
 
-		private bool SkipMap(in SequenceReader<byte> source, in CollectionContext collectionContext, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
+		private bool SkipMap(ref SequenceReader<byte> source, in CollectionContext collectionContext, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			collectionContext.IncrementDepth();
 
 			var initialConsumed = consumed;
-			var type = this.DecodeArrayOrMapHeaderCore(source, ref consumed, out var header, out var mapCount, out requestHint);
+			var type = this.DecodeArrayOrMapHeaderCore(ref source, out var header, out var mapCount, out requestHint);
 			if (requestHint != 0)
 			{
 				return false;
@@ -76,10 +81,12 @@ private bool SkipMap(in SequenceReader<byte> source, in CollectionContext collec
 
 			if (!type.IsMap)
 			{
-				MessagePackThrow.TypeIsNotMap(header, source.Consumed - consumed + initialConsumed);
+				MessagePackThrow.TypeIsNotMap(header, initialConsumed);
 			}
 
-			if (!this.SkipItems(source, collectionContext, mapCount * 2, ref consumed, out requestHint, cancellationToken))
+			consumed = source.Consumed - initialConsumed;
+
+			if (!this.SkipItems(ref source, collectionContext, mapCount * 2, ref consumed, out requestHint, cancellationToken))
 			{
 				return false;
 			}
@@ -88,11 +95,11 @@ private bool SkipMap(in SequenceReader<byte> source, in CollectionContext collec
 			return true;
 		}
 
-		private bool SkipItems(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
+		private bool SkipItems(ref SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, ref long consumed, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			while (itemsCount > 0)
 			{
-				if (!this.TryPeek(source, out var header))
+				if (!source.TryPeek(out var header))
 				{
 					requestHint = 1;
 					return false;
@@ -104,14 +111,14 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 
 				if (header >= MessagePackCode.MinimumFixedArray && header <= MessagePackCode.MaximumFixedArray)
 				{
-					if (!this.SkipArray(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+					if (!this.SkipArray(ref source, collectionContext, ref consumed, out requestHint, cancellationToken))
 					{
 						return false;
 					}
 				}
 				else if (header >= MessagePackCode.MinimumFixedMap && header <= MessagePackCode.MaximumFixedMap)
 				{
-					if (!this.SkipMap(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+					if (!this.SkipMap(ref source, collectionContext, ref consumed, out requestHint, cancellationToken))
 					{
 						return false;
 					}
@@ -161,7 +168,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 						case MessagePackCode.Bin16:
 						case MessagePackCode.Raw16:
 						{
-							length = ReadValue<ushort>(source, offset: 0, out requestHint);
+							length = ReadValue<ushort>(ref source, offset: 0, out requestHint);
 							if (requestHint != 0)
 							{
 								source.Rewind(consumed);
@@ -174,7 +181,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 						case MessagePackCode.Bin32:
 						case MessagePackCode.Raw32:
 						{
-							length = ReadValue<uint>(source, offset: 0, out requestHint);
+							length = ReadValue<uint>(ref source, offset: 0, out requestHint);
 							if (requestHint != 0)
 							{
 								source.Rewind(consumed);
@@ -223,7 +230,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 						}
 						case MessagePackCode.Ext16:
 						{
-							length = ReadValue<ushort>(source, offset: 0, out requestHint);
+							length = ReadValue<ushort>(ref source, offset: 0, out requestHint);
 							if (requestHint != 0)
 							{
 								source.Rewind(consumed);
@@ -235,7 +242,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 						}
 						case MessagePackCode.Ext32:
 						{
-							length = ReadValue<int>(source, offset: 0, out requestHint);
+							length = ReadValue<int>(ref source, offset: 0, out requestHint);
 							if (requestHint != 0)
 							{
 								source.Rewind(consumed);
@@ -248,7 +255,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 						case MessagePackCode.Array16:
 						case MessagePackCode.Array32:
 						{
-							if (!this.SkipArray(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+							if (!this.SkipArray(ref source, collectionContext, ref consumed, out requestHint, cancellationToken))
 							{
 								return false;
 							}
@@ -257,7 +264,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 						case MessagePackCode.Map16:
 						case MessagePackCode.Map32:
 						{
-							if (!this.SkipMap(source, collectionContext, ref consumed, out requestHint, cancellationToken))
+							if (!this.SkipMap(ref source, collectionContext, ref consumed, out requestHint, cancellationToken))
 							{
 								return false;
 							}
@@ -266,7 +273,7 @@ private bool SkipItems(in SequenceReader<byte> source, in CollectionContext coll
 					}
 				}
 
-				if (length > 0 && !SkipLength(source, length, ref consumed, out requestHint))
+				if (length > 0 && !SkipLength(ref source, length, ref consumed, out requestHint))
 				{
 					return false;
 				}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs
index 04f043e73..af13ee46a 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Strings.cs
@@ -14,9 +14,11 @@ namespace MsgPack.Internal
 	public partial class MessagePackDecoder
 	{
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override bool GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
+		public sealed override bool GetRawString(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			var length = this.PeekRawStringLength(source, out requestHint, cancellationToken);
+			var subReader = source;
+
+			var length = this.GetRawStringLength(ref subReader, out var headerLength, out requestHint, cancellationToken);
 			if (length < 0)
 			{
 				rawString = default;
@@ -25,17 +27,17 @@ public override bool GetRawString(in SequenceReader<byte> source, out ReadOnlySp
 
 			if (source.UnreadSpan.Length < length)
 			{
-				rawString = source.UnreadSpan.Slice(0, length);
+				rawString = source.UnreadSpan.Slice(0, length + headerLength);
 				source.Advance(length);
 				requestHint = 0;
 				return true;
 			}
 
-			return this.GetRawStringMultiSegment(source, out rawString, out requestHint, length, cancellationToken);
+			return this.GetRawStringMultiSegment(ref source, out rawString, out requestHint, length + headerLength, cancellationToken);
 		}
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
-		private bool GetRawStringMultiSegment(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, int length, CancellationToken cancellationToken)
+		private bool GetRawStringMultiSegment(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, int length, CancellationToken cancellationToken)
 		{
 			if (source.Remaining < length)
 			{
@@ -45,6 +47,7 @@ private bool GetRawStringMultiSegment(in SequenceReader<byte> source, out ReadOn
 			}
 
 			var result = new byte[length];
+
 			var bufferSpan = result.AsSpan();
 
 			var copyLength = Math.Min(this.Options.CancellationSupportThreshold, length);
@@ -65,9 +68,10 @@ private bool GetRawStringMultiSegment(in SequenceReader<byte> source, out ReadOn
 			return true;
 		}
 
-		private int PeekRawStringLength(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private int GetRawStringLength(ref SequenceReader<byte> source, out int consumed, out int requestHint, CancellationToken cancellationToken)
 		{
-			var length = this.DecodeStringHeader(source, out var header, out requestHint, out _);
+			var length = this.DecodeStringHeader(ref source, out var header, out requestHint, out consumed);
 			if (requestHint != 0)
 			{
 				return default;
@@ -75,15 +79,15 @@ private int PeekRawStringLength(in SequenceReader<byte> source, out int requestH
 
 			if (length > Int32.MaxValue)
 			{
-				MessagePackThrow.TooLargeByteLength(header, source.Consumed, length);
+				MessagePackThrow.TooLargeByteLength(header, source.Consumed - consumed, length);
 			}
 
 			return (int)length;
 		}
 
-		private long DecodeStringHeader(in SequenceReader<byte> source, out byte header, out int requestHint, out int consumed)
+		private long DecodeStringHeader(ref SequenceReader<byte> source, out byte header, out int requestHint, out int consumed)
 		{
-			if (!this.TryPeek(source, out header))
+			if (!source.TryPeek(out header))
 			{
 				requestHint = 1;
 				consumed = 0;
@@ -94,6 +98,7 @@ private long DecodeStringHeader(in SequenceReader<byte> source, out byte header,
 			{
 				requestHint = 0;
 				consumed = 1;
+				source.Advance(1);
 				return header - MessagePackCode.MinimumFixedRaw;
 			}
 
@@ -102,19 +107,19 @@ private long DecodeStringHeader(in SequenceReader<byte> source, out byte header,
 			{
 				case MessagePackCode.Str8:
 				{
-					length = ReadByte(source, offset: 1, out requestHint);
+					length = ReadByte(ref source, offset: 1, out requestHint);
 					consumed = 2;
 					break;
 				}
 				case MessagePackCode.Str16:
 				{
-					length = ReadValue<ushort>(source, offset: 1, out requestHint);
+					length = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 					consumed = 3;
 					break;
 				}
 				case MessagePackCode.Str32:
 				{
-					length = ReadValue<uint>(source, offset: 1, out requestHint);
+					length = ReadValue<uint>(ref source, offset: 1, out requestHint);
 					consumed = 5;
 					break;
 				}
@@ -128,34 +133,35 @@ private long DecodeStringHeader(in SequenceReader<byte> source, out byte header,
 				}
 			}
 
+			source.Advance(consumed);
 			return requestHint == 0 ? length : 0;
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override string? DecodeNullableString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public sealed override string? DecodeNullableString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeString(source, out requestHint, encoding, cancellationToken);
+			return this.DecodeString(ref source, out requestHint, encoding, cancellationToken);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override string? DecodeString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public sealed override string? DecodeString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			var length = this.DecodeStringHeader(source, out _, out requestHint, out var consumed);
+			var length = this.DecodeStringHeader(ref source, out _, out requestHint, out var consumed);
 			if (requestHint != 0)
 			{
 				return default;
 			}
 
-			if (source.Remaining < length + consumed)
+			if (source.Remaining < length)
 			{
-				requestHint = (int)((length + consumed - source.Remaining) & Int32.MaxValue);
+				requestHint = (int)((length - source.Remaining) & Int32.MaxValue);
 				return default;
 			}
 
@@ -167,34 +173,34 @@ private long DecodeStringHeader(in SequenceReader<byte> source, out byte header,
 			if (encoding == null && length <= this.Options.CancellationSupportThreshold)
 			{
 				// fast-path
-				var value = Utf8EncodingNonBom.Instance.GetString(source.UnreadSpan.Slice(consumed, (int)length));
-				source.Advance(length + consumed);
+				var value = Utf8EncodingNonBom.Instance.GetString(source.UnreadSpan.Slice(0, (int)length));
+				source.Advance(length);
 				requestHint = 0;
 				return value;
 			}
 
-			var result = (encoding ?? Utf8EncodingNonBom.Instance).GetStringMultiSegment(source.Sequence.Slice(consumed), this.Options.CharBufferPool, cancellationToken);
-			source.Advance(length + consumed);
+			var result = (encoding ?? Utf8EncodingNonBom.Instance).GetStringMultiSegment(source.Sequence.Slice(source.Position), this.Options.CharBufferPool, cancellationToken);
+			source.Advance(length);
 			requestHint = 0;
 			return result;
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override byte[]? DecodeNullableBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		public sealed override byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			if (this.TryReadNull(source))
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeBinary(source, out requestHint, cancellationToken);
+			return this.DecodeBinary(ref source, out requestHint, cancellationToken);
 		}
 
-		private int DecodeBinaryHeader(in SequenceReader<byte> source, out int requestHint, out int consumed)
+		private int DecodeBinaryHeader(ref SequenceReader<byte> source, out int requestHint, out int consumed)
 		{
-			if (!this.TryPeek(source, out var header))
+			if (!source.TryPeek(out var header))
 			{
 				requestHint = 1;
 				consumed = 0;
@@ -214,21 +220,21 @@ private int DecodeBinaryHeader(in SequenceReader<byte> source, out int requestHi
 				case MessagePackCode.Str8:
 				case MessagePackCode.Bin8:
 				{
-					length = ReadByte(source, offset: 1, out requestHint);
+					length = ReadByte(ref source, offset: 1, out requestHint);
 					consumed = 2;
 					break;
 				}
 				case MessagePackCode.Str16:
 				case MessagePackCode.Bin16:
 				{
-					length = ReadValue<ushort>(source, offset: 1, out requestHint);
+					length = ReadValue<ushort>(ref source, offset: 1, out requestHint);
 					consumed = 3;
 					break;
 				}
 				case MessagePackCode.Str32:
 				case MessagePackCode.Bin32:
 				{
-					length = ReadValue<int>(source, offset: 1, out requestHint);
+					length = ReadValue<int>(ref source, offset: 1, out requestHint);
 					if (length < 0)
 					{
 						MessagePackThrow.TooLargeByteLength(header, source.Consumed - 5, unchecked((uint)length));
@@ -252,9 +258,9 @@ private int DecodeBinaryHeader(in SequenceReader<byte> source, out int requestHi
 
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override byte[]? DecodeBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		public sealed override byte[]? DecodeBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			var length = this.DecodeBinaryHeader(source, out requestHint, out var consumed);
+			var length = this.DecodeBinaryHeader(ref source, out requestHint, out var consumed);
 			if(requestHint != 0)
 			{
 				return default;
@@ -265,9 +271,9 @@ private int DecodeBinaryHeader(in SequenceReader<byte> source, out int requestHi
 				Throw.BinaryLengthExceeded(source.Consumed - consumed, length, this.Options.MaxBinaryLengthInBytes);
 			}
 
-			if(source.Remaining < length + consumed)
+			if(source.Remaining < length)
 			{
-				requestHint = length + consumed - (int)source.Remaining;
+				requestHint = length - (int)source.Remaining;
 				return default;
 			}
 
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
index d244bce91..f08ec168e 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
@@ -26,9 +26,9 @@ public MessagePackDecoder(MessagePackDecoderOptions options)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override bool DecodeBoolean(in SequenceReader<byte> source, out int requestHint)
+		public override bool DecodeBoolean(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (!this.TryPeek(source, out var header))
+			if (!source.TryPeek(out var header))
 			{
 				requestHint = 1;
 				return false;
@@ -56,9 +56,18 @@ public override bool DecodeBoolean(in SequenceReader<byte> source, out int reque
 			}
 		}
 
-		private bool TryReadNull(in SequenceReader<byte> source)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override  bool TryDecodeNull(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (this.TryPeek(source, out var b) && b == MessagePackCode.NilValue)
+			if(!source.TryPeek(out var b))
+			{
+				requestHint = 1;
+				return default;
+			}
+
+			requestHint = 0;
+
+			if (b == MessagePackCode.NilValue)
 			{
 				source.Advance(1);
 				return true;
@@ -67,7 +76,7 @@ private bool TryReadNull(in SequenceReader<byte> source)
 			return false;
 		}
 
-		private static void ParseNumberHeader(byte header, in SequenceReader<byte> source, Type type, out int length, out NumberKind kind)
+		private static void ParseNumberHeader(byte header, ref SequenceReader<byte> source, Type type, out int length, out NumberKind kind)
 		{
 			// 0xD0-D3 -- SignedIntN
 			// 1101-0000 -> 1101-0011
@@ -79,16 +88,16 @@ private static void ParseNumberHeader(byte header, in SequenceReader<byte> sourc
 			if ((header & 0xD3) == header)
 			{
 				// SignedIntN
-				length = (int)Math.Pow(2, (header & 0x3)) + 1;
+				length = (int)Math.Pow(2, (header & 0x3));
 				kind = NumberKind.Signed;
 			}
 			else if ((header & 0xCC) == header)
 			{
 				// UnsignedIntN
-				length = (int)Math.Pow(2, (header & 0x3)) + 1;
+				length = (int)Math.Pow(2, (header & 0x3));
 				kind = NumberKind.Unsigned;
 			}
-			if (header == MessagePackCode.Real64)
+			else if (header == MessagePackCode.Real64)
 			{
 				length = 9;
 				kind = NumberKind.Double;
@@ -107,7 +116,7 @@ private static void ParseNumberHeader(byte header, in SequenceReader<byte> sourc
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static byte ReadByte(in SequenceReader<byte> source, int offset, out int requestHint)
+		private static byte ReadByte(ref SequenceReader<byte> source, int offset, out int requestHint)
 		{
 			if (source.UnreadSpan.Length > offset + 1)
 			{
@@ -117,10 +126,10 @@ private static byte ReadByte(in SequenceReader<byte> source, int offset, out int
 				return result;
 			}
 
-			return ReadByteMultiSegment(source, offset, out requestHint);
+			return ReadByteMultiSegment(ref source, offset, out requestHint);
 		}
 
-		private static byte ReadByteMultiSegment(in SequenceReader<byte> source, int offset, out int requestHint)
+		private static byte ReadByteMultiSegment(ref SequenceReader<byte> source, int offset, out int requestHint)
 		{
 			if (source.Remaining < offset + 1)
 			{
@@ -136,11 +145,11 @@ private static byte ReadByteMultiSegment(in SequenceReader<byte> source, int off
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static sbyte ReadSByte(in SequenceReader<byte> source, int offset, out int requestHint)
-			=> unchecked((sbyte)ReadByte(source, offset, out requestHint));
+		private static sbyte ReadSByte(ref SequenceReader<byte> source, int offset, out int requestHint)
+			=> unchecked((sbyte)ReadByte(ref source, offset, out requestHint));
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static unsafe T ReadValue<T>(in SequenceReader<byte> source, int offset, out int requestHint)
+		private static unsafe T ReadValue<T>(ref SequenceReader<byte> source, int offset, out int requestHint)
 			where T : unmanaged
 		{
 			if (source.UnreadSpan.Length > offset + sizeof(T))
@@ -151,10 +160,10 @@ private static unsafe T ReadValue<T>(in SequenceReader<byte> source, int offset,
 				return result;
 			}
 
-			return ReadMultiSegment<T>(source, offset, out requestHint);
+			return ReadMultiSegment<T>(ref source, offset, out requestHint);
 		}
 
-		private static unsafe T ReadMultiSegment<T>(in SequenceReader<byte> source, int offset, out int requestHint)
+		private static unsafe T ReadMultiSegment<T>(ref SequenceReader<byte> source, int offset, out int requestHint)
 				where T : unmanaged
 		{
 			if (source.Remaining < offset + sizeof(T))
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs
index d38e4fd18..aa94028cc 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.cs
@@ -19,7 +19,7 @@ partial class MessagePackEncoder
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeInt32(Int32 value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var leastByte = value & 0x000000FF;
 			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
@@ -38,7 +38,7 @@ public sealed override void EncodeInt32(Int32 value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeUInt32(UInt32 value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var leastByte = value & 0x000000FF;
 			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
@@ -57,7 +57,7 @@ public sealed override void EncodeUInt32(UInt32 value, IBufferWriter<byte> buffe
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeInt64(Int64 value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var leastByte = value & 0x000000FF;
 			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
@@ -76,7 +76,7 @@ public sealed override void EncodeInt64(Int64 value, IBufferWriter<byte> buffer)
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeUInt64(UInt64 value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var leastByte = value & 0x000000FF;
 			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt
index d82abb48f..4796d7ef4 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Integers.tt
@@ -25,7 +25,7 @@ foreach (var inputType in new []{ "Int32", "UInt32", "Int64", "UInt64" })
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void Encode<#= inputType #>(<#= inputType #> value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var leastByte = value & 0x000000FF;
 			if (leastByte == value || (value ^ 0xFFFFFF00) == leastByte)
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
index cd5b82f23..c5b737a4c 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
@@ -24,8 +24,7 @@ partial class MessagePackEncoder
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
-			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+			buffer = Ensure.NotNull(buffer);
 			if (value.Length == 0)
 			{
 				buffer.GetSpan(1)[0] = MessagePackCode.MinimumFixedRaw;
@@ -33,6 +32,8 @@ public sealed override void EncodeString(ReadOnlySpan<char> value, IBufferWriter
 				return;
 			}
 
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+
 			if (value.Length < 256)
 			{
 				var valueLength = unchecked((int)value.Length);
@@ -41,12 +42,10 @@ public sealed override void EncodeString(ReadOnlySpan<char> value, IBufferWriter
 				if (maxByteLength < 32)
 				{
 					// stack alloc is fastest
-					Span<byte> encodingBuffer = stackalloc byte[maxByteLength];
-					var actualLength = encoding.GetBytes(value, encodingBuffer);
-					var sink = buffer.GetSpan(actualLength + 1);
+					var sink = buffer.GetSpan(maxByteLength + 1);
+					var actualLength = encoding.GetBytes(value, sink.Slice(1));
 					sink[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | actualLength));
-					encodingBuffer.Slice(actualLength).CopyTo(sink.Slice(1));
-					buffer.Advance(sink.Length);
+					buffer.Advance(actualLength + 1);
 					return;
 				}
 				else if (maxByteLength < 256)
@@ -96,7 +95,7 @@ private void EncodeStringSlow(ReadOnlySpan<char> value, IBufferWriter<byte> buff
 					try
 					{
 						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
-						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
+						buffer.Write(encodingBuffer.AsSpan(0, totalLength));
 					}
 					finally
 					{
@@ -145,8 +144,7 @@ private unsafe int EncodeLargeString1Path(ReadOnlySpan<char> value, IBufferWrite
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
-			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+			buffer = Ensure.NotNull(buffer);
 			if (value.Length > UInt32.MaxValue)
 			{
 				Throw.TooLargeCharLength(value.Length);
@@ -160,6 +158,8 @@ public sealed override void EncodeString(in ReadOnlySequence<char> value, IBuffe
 				return;
 			}
 
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+
 			if (value.Length < 256)
 			{
 				var valueLength = unchecked((int)value.Length);
@@ -168,12 +168,10 @@ public sealed override void EncodeString(in ReadOnlySequence<char> value, IBuffe
 				if (maxByteLength < 32)
 				{
 					// stack alloc is fastest
-					Span<byte> encodingBuffer = stackalloc byte[maxByteLength];
-					var actualLength = encoding.GetBytes(value, encodingBuffer);
-					var sink = buffer.GetSpan(actualLength + 1);
+					var sink = buffer.GetSpan(maxByteLength + 1);
+					var actualLength = encoding.GetBytes(value, sink.Slice(1));
 					sink[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | actualLength));
-					encodingBuffer.Slice(actualLength).CopyTo(sink.Slice(1));
-					buffer.Advance(sink.Length);
+					buffer.Advance(actualLength + 1);
 					return;
 				}
 				else if (maxByteLength < 256)
@@ -223,7 +221,7 @@ private void EncodeStringSlow(in ReadOnlySequence<char> value, IBufferWriter<byt
 					try
 					{
 						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
-						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
+						buffer.Write(encodingBuffer.AsSpan(0, totalLength));
 					}
 					finally
 					{
@@ -234,7 +232,6 @@ private void EncodeStringSlow(in ReadOnlySequence<char> value, IBufferWriter<byt
 
 			this.EncodeHugeString2Path(value, buffer, encoding);
 		}
-
 		
 		private unsafe int EncodeLargeString1Path(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding encoding, uint estimatedLength, ArraySegment<byte> sinkBufferSegment)
 		{
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt
index 7f8eb2206..eb7638a19 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.tt
@@ -36,8 +36,7 @@ foreach (var inputType in
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeString(<#= inputType.Signature #><char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
-			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+			buffer = Ensure.NotNull(buffer);
 <#
 	if (inputType.MayBe64BitLength)
 	{
@@ -58,6 +57,8 @@ foreach (var inputType in
 				return;
 			}
 
+			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+
 			if (value.Length < 256)
 			{
 				var valueLength = unchecked((int)value.Length);
@@ -66,12 +67,10 @@ foreach (var inputType in
 				if (maxByteLength < 32)
 				{
 					// stack alloc is fastest
-					Span<byte> encodingBuffer = stackalloc byte[maxByteLength];
-					var actualLength = encoding.GetBytes(value, encodingBuffer);
-					var sink = buffer.GetSpan(actualLength + 1);
+					var sink = buffer.GetSpan(maxByteLength + 1);
+					var actualLength = encoding.GetBytes(value, sink.Slice(1));
 					sink[0] = unchecked((byte)(MessagePackCode.MinimumFixedRaw | actualLength));
-					encodingBuffer.Slice(actualLength).CopyTo(sink.Slice(1));
-					buffer.Advance(sink.Length);
+					buffer.Advance(actualLength + 1);
 					return;
 				}
 				else if (maxByteLength < 256)
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
index 98fc04b86..153da2005 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
@@ -25,10 +25,14 @@ public abstract partial class MessagePackEncoder : Encoder<MessagePackExtensionT
 		protected MessagePackEncoder(MessagePackEncoderOptions options)
 			: base(options) { }
 
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override void EncodeRawString(ReadOnlySpan<byte> rawString, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+			=> Ensure.NotNull(buffer).Write(rawString);
+
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeSingle(float value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var span = buffer.GetSpan(sizeof(float) + 1);
 
@@ -41,7 +45,7 @@ public sealed override void EncodeSingle(float value, IBufferWriter<byte> buffer
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeDouble(double value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var span = buffer.GetSpan(sizeof(double) + 1);
 
@@ -54,7 +58,7 @@ public sealed override void EncodeDouble(double value, IBufferWriter<byte> buffe
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeBoolean(bool value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var span = buffer.GetSpan(1);
 			span[0] = unchecked((byte)(value ? MessagePackCode.TrueValue : MessagePackCode.FalseValue));
@@ -64,7 +68,7 @@ public sealed override void EncodeBoolean(bool value, IBufferWriter<byte> buffer
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeArrayStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 			collectionContext.IncrementDepth();
 
 			if (length < 16)
@@ -103,7 +107,7 @@ public sealed override void EncodeArrayItemEnd(int index, IBufferWriter<byte> bu
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeMapStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (length < 16)
 			{
@@ -147,7 +151,7 @@ public sealed override void EncodeMapValueEnd(int index, IBufferWriter<byte> buf
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeNull(IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			var span = buffer.GetSpan(1);
 			span[0] = MessagePackCode.NilValue;
@@ -199,7 +203,7 @@ private void EncodeHugeString2Path(in ReadOnlySequence<char> value, IBufferWrite
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public sealed override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 			
 			var span = buffer.GetSpan(5);
 			var used = this.EncodeStringHeader(unchecked((uint)encodedValue.Length), span);
diff --git a/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs b/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs
index 93ef16a78..18bb5f3e1 100644
--- a/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs
+++ b/src/MsgPack.Core/Internal/MsgPackStringTrie`1.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Buffers.Binary;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 
@@ -12,6 +13,7 @@ namespace MsgPack.Internal
 	// Basic idea is borrwed from AutomataDictionary of Message Pack C#
 	// https://github.com/neuecc/MessagePack-CSharp/blob/51649e0d7b8641ad5d3cdd6dfdc130c7671066fc/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Internal/AutomataDictionary.cs#L1
 
+#warning TODO: Pubternal
 	public sealed class MsgPackStringTrie<T>
 	{
 		private readonly T _default;
@@ -24,7 +26,10 @@ public MsgPackStringTrie(T defaultValue)
 		}
 
 		public bool TryAdd(ReadOnlySpan<byte> utf8Key, T value)
-			=> this.TryAdd(this._root, GenerateKeyHead(ref utf8Key), utf8Key, value);
+			=> this.TryAdd(this._root, MsgPackStringTrieKey.GetAsMsgPackString(ref utf8Key), utf8Key, value);
+
+		public bool TryAddRaw(ReadOnlySpan<byte> utf8Key, T value)
+			=> this.TryAdd(this._root, MsgPackStringTrieKey.GetRaw64(ref utf8Key), utf8Key, value);
 
 		private static int BinarySearch(ulong[] nodes, ulong key)
 		{
@@ -55,7 +60,7 @@ private static int BinarySearch(ulong[] nodes, ulong key)
 
 		public T GetOrDefault(ReadOnlySpan<byte> msgPackStringKey)
 		{
-			var result = this.Find(this._root, GenerateKeyRest(ref msgPackStringKey), msgPackStringKey);
+			var result = this.Find(this._root, MsgPackStringTrieKey.GetRaw64(ref msgPackStringKey), msgPackStringKey);
 			return result != null ? result.Value : this._default;
 		}
 
@@ -92,7 +97,7 @@ private bool TryAdd(Node parent, ulong key, ReadOnlySpan<byte> trailingKey, T va
 				nodes = found.ChildNodes;
 				keys = found.ChildKeys;
 
-				key = GenerateKeyRest(ref trailingKey);
+				key = MsgPackStringTrieKey.GetRaw64(ref trailingKey);
 			}
 		}
 
@@ -126,7 +131,7 @@ private bool TryAdd(Node parent, ulong key, ReadOnlySpan<byte> trailingKey, T va
 
 				nodes = found.ChildNodes;
 				keys = found.ChildKeys;
-				key = GenerateKeyRest(ref trailingKey);
+				key = MsgPackStringTrieKey.GetRaw64(ref trailingKey);
 			}
 		}
 
@@ -168,11 +173,260 @@ private void AddNode(Node node, ulong key, ReadOnlySpan<byte> trailingKey, int t
 				Debug.Assert(keys.Length == 1);
 				targetIndex = 0;
 
-				key = GenerateKeyRest(ref trailingKey);
+				key = MsgPackStringTrieKey.GetRaw64(ref trailingKey);
+			}
+		}
+
+		private sealed class Node
+		{
+			// There 2 separate array to improve search performance due to CPU cache line and prediction.
+			public ulong[] ChildKeys;
+			public Node[] ChildNodes;
+			public readonly T Value;
+
+			public Node(T value, Node[] childNodes, ulong[] childKeys)
+			{
+				this.Value = value;
+				this.ChildNodes = childNodes;
+				this.ChildKeys = childKeys;
+			}
+		}
+
+#warning TODO: REMOVE
+		public IEnumerable<(ulong[] Keys, T Value)> GetDebugView()
+			=> GetDebugView(this._root, new List<ulong>());
+
+		private static IEnumerable<(ulong[] Keys, T Value)> GetDebugView(Node node, List<ulong> keyChain)
+		{
+			if (node.ChildKeys.Length == 0)
+			{
+				yield return (keyChain.ToArray(), node.Value);
+			}
+			else
+			{
+				for (var i = 0; i < node.ChildKeys.Length; i++)
+				{
+					var childKey = node.ChildKeys[i];
+					keyChain.Add(childKey);
+					var childNode = node.ChildNodes[i];
+					foreach (var item in GetDebugView(childNode, keyChain))
+					{
+						yield return item;
+					}
+					keyChain.RemoveAt(keyChain.Count - 1);
+				}
+			}
+		}
+	}
+
+#if FALSE
+	public sealed class MsgPackStringTrie32<T>
+	{
+		private readonly T _default;
+		private readonly Node _root;
+
+		public MsgPackStringTrie32(T defaultValue)
+		{
+			this._default = defaultValue;
+			this._root = new Node(defaultValue, Array.Empty<Node>(), Array.Empty<uint>());
+		}
+
+		public bool TryAdd(ReadOnlySpan<byte> utf8Key, T value)
+			=> this.TryAdd(this._root, MsgPackStringTrieKey.GetAsMsgPackString32(ref utf8Key), utf8Key, value);
+
+		private static int BinarySearch(uint[] nodes, ulong key)
+		{
+			// Span<T>.BinarySearch is slower maybe because of ComapreTo method overhead, so we implement binary search manually.
+			var low = 0;
+			var high = nodes.Length - 1;
+			while (low <= high)
+			{
+				// Peformance trick borrowed from https://github.com/dotnet/runtime/blob/f2786223508c0c70040fbf48ec3a39a607dd7f75/src/libraries/System.Private.CoreLib/src/System/SpanHelpers.BinarySearch.cs#L42
+				var index = unchecked((int)(((uint)high + (uint)low) >> 1));
+				var found = nodes[index];
+				if (found == key)
+				{
+					return index;
+				}
+				else if (found < key)
+				{
+					low = index + 1;
+				}
+				else
+				{
+					high = index - 1;
+				}
+			}
+
+			return ~low;
+		}
+
+		public T GetOrDefault(ReadOnlySpan<byte> msgPackStringKey)
+		{
+			var result = this.Find(this._root, MsgPackStringTrieKey.GetRaw32(ref msgPackStringKey), msgPackStringKey);
+			return result != null ? result.Value : this._default;
+		}
+
+		private bool TryAdd(Node parent, uint key, ReadOnlySpan<byte> trailingKey, T value)
+		{
+			var nodes = parent.ChildNodes;
+			var keys = parent.ChildKeys;
+
+			while (true)
+			{
+				var index = BinarySearch(keys, key);
+
+				if (index < 0)
+				{
+					// No matching leaf.
+					this.AddNode(parent, key, trailingKey, ~index, value, out _);
+					return true;
+				}
+
+				var found = nodes[index];
+				if (trailingKey.IsEmpty)
+				{
+					// The leaf matches.
+					return false;
+				}
+
+				if (found.ChildNodes.Length == 0)
+				{
+					// Search key is longer than trie path.
+					this.AddNode(found, key, trailingKey, 0, value, out _);
+					return true;
+				}
+
+				nodes = found.ChildNodes;
+				keys = found.ChildKeys;
+
+				key = MsgPackStringTrieKey.GetRaw32(ref trailingKey);
+			}
+		}
+
+		private Node? Find(Node parent, uint key, ReadOnlySpan<byte> trailingKey)
+		{
+			var nodes = parent.ChildNodes;
+			var keys = parent.ChildKeys;
+
+			while (true)
+			{
+				var index = BinarySearch(keys, key);
+
+				if (index < 0)
+				{
+					// No matching leaf.
+					return null;
+				}
+
+				var found = nodes[index];
+				if (trailingKey.IsEmpty)
+				{
+					// The leaf matches.
+					return found;
+				}
+
+				if (found.ChildNodes.Length == 0)
+				{
+					// Search key is longer than trie path.
+					return null;
+				}
+
+				nodes = found.ChildNodes;
+				keys = found.ChildKeys;
+				key = MsgPackStringTrieKey.GetRaw32(ref trailingKey);
 			}
 		}
 
-		private static ulong GenerateKeyHead(ref ReadOnlySpan<byte> source)
+		private void AddNode(Node node, uint key, ReadOnlySpan<byte> trailingKey, int targetIndex, T value, out Node result)
+		{
+			Array.Resize(ref node.ChildKeys, node.ChildKeys.Length + 1);
+			Array.Resize(ref node.ChildNodes, node.ChildNodes.Length + 1);
+			var nodes = node.ChildNodes;
+			var keys = node.ChildKeys;
+
+			while (true)
+			{
+				var child =
+					trailingKey.IsEmpty ?
+						new Node(value, Array.Empty<Node>(), Array.Empty<uint>()) :
+						new Node(this._default, new Node[1], new uint[1]);
+
+				if (nodes.Length > 1 && targetIndex < nodes.Length - 1)
+				{
+					// Shift existing.
+					Array.Copy(nodes, targetIndex, nodes, targetIndex + 1, nodes.Length - targetIndex - 1);
+					Array.Copy(keys, targetIndex, keys, targetIndex + 1, keys.Length - targetIndex - 1);
+				}
+
+				nodes[targetIndex] = child;
+				keys[targetIndex] = key;
+
+				if (trailingKey.IsEmpty)
+				{
+					// This is leaf.
+					result = child;
+					return;
+				}
+
+				nodes = child.ChildNodes;
+				keys = child.ChildKeys;
+
+				Debug.Assert(nodes.Length == 1);
+				Debug.Assert(keys.Length == 1);
+				targetIndex = 0;
+
+				key = MsgPackStringTrieKey.GetRaw32(ref trailingKey);
+			}
+		}
+
+		private sealed class Node
+		{
+			// There 2 separate array to improve search performance due to CPU cache line and prediction.
+			public uint[] ChildKeys;
+			public Node[] ChildNodes;
+			public readonly T Value;
+
+			public Node(T value, Node[] childNodes, uint[] childKeys)
+			{
+				this.Value = value;
+				this.ChildNodes = childNodes;
+				this.ChildKeys = childKeys;
+			}
+		}
+
+#warning TODO: REMOVE
+		public IEnumerable<(uint[] Keys, T Value)> GetDebugView()
+			=> GetDebugView(this._root, new List<uint>());
+
+		private static IEnumerable<(uint[] Keys, T Value)> GetDebugView(Node node, List<uint> keyChain)
+		{
+			if (node.ChildKeys.Length == 0)
+			{
+				yield return (keyChain.ToArray(), node.Value);
+			}
+			else
+			{
+				for (var i = 0; i < node.ChildKeys.Length; i++)
+				{
+					var childKey = node.ChildKeys[i];
+					keyChain.Add(childKey);
+					var childNode = node.ChildNodes[i];
+					foreach (var item in GetDebugView(childNode, keyChain))
+					{
+						yield return item;
+					}
+					keyChain.RemoveAt(keyChain.Count - 1);
+				}
+			}
+		}
+	}
+#endif
+
+#warning TODO: Pubternal
+	public static class MsgPackStringTrieKey
+	{
+		public static ulong GetAsMsgPackString(ref ReadOnlySpan<byte> source)
 		{
 			Span<byte> bytes = stackalloc byte[sizeof(ulong)];
 			var buffer = bytes;
@@ -212,7 +466,7 @@ private static ulong GenerateKeyHead(ref ReadOnlySpan<byte> source)
 			return MemoryMarshal.Cast<byte, ulong>(bytes)[0];
 		}
 
-		private static ulong GenerateKeyRest(ref ReadOnlySpan<byte> source)
+		public static ulong GetRaw64(ref ReadOnlySpan<byte> source)
 		{
 			Debug.Assert(!source.IsEmpty);
 			if (source.Length >= sizeof(ulong))
@@ -281,19 +535,87 @@ private static ulong GenerateKeyRest(ref ReadOnlySpan<byte> source)
 			}
 		}
 
-		private sealed class Node
+#if FALSE
+		public static uint GetAsMsgPackString32(ref ReadOnlySpan<byte> source)
 		{
-			// There 2 separate array to improve search performance due to CPU cache line and prediction.
-			public ulong[] ChildKeys;
-			public Node[] ChildNodes;
-			public readonly T Value;
+			Span<byte> bytes = stackalloc byte[sizeof(uint)];
+			var buffer = bytes;
+			int consumes;
+			if (source.Length < 16)
+			{
+				buffer[0] = (byte)(0xA0 | source.Length);
+				buffer = buffer.Slice(1);
+				consumes = Math.Min(source.Length, sizeof(uint) - 1);
+			}
+			else if (source.Length <= Byte.MaxValue)
+			{
+				buffer[0] = 0xD9;
+				buffer[1] = (byte)source.Length;
+				buffer = buffer.Slice(2);
+				consumes = Math.Min(source.Length, sizeof(uint) - 1 - 1);
+			}
+			else if (source.Length <= UInt16.MaxValue)
+			{
+				buffer[0] = 0xDA;
+				buffer = buffer.Slice(1);
+				BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)source.Length);
+				buffer = buffer.Slice(sizeof(ushort));
+				consumes = Math.Min(source.Length, sizeof(uint) - 1 - sizeof(ushort));
+			}
+			else
+			{
+				buffer[0] = 0xDB;
+				buffer = buffer.Slice(1);
+				BinaryPrimitives.WriteInt32BigEndian(buffer, source.Length);
+				buffer = buffer.Slice(sizeof(int));
+				consumes = Math.Min(source.Length, sizeof(uint) - 1 - sizeof(int));
+			}
 
-			public Node(T value, Node[] childNodes, ulong[] childKeys)
+			source.Slice(0, consumes).CopyTo(buffer);
+			source = source.Slice(consumes);
+			return MemoryMarshal.Cast<byte, uint>(bytes)[0];
+		}
+
+		public static uint GetRaw32(ref ReadOnlySpan<byte> source)
+		{
+			Debug.Assert(!source.IsEmpty);
+			if (source.Length >= sizeof(uint))
 			{
-				this.Value = value;
-				this.ChildNodes = childNodes;
-				this.ChildKeys = childKeys;
+				var result = MemoryMarshal.Cast<byte, uint>(source)[0];
+				source = source.Slice(sizeof(uint));
+				return result;
+			}
+			else
+			{
+				uint result;
+				unchecked
+				{
+					switch (source.Length)
+					{
+						case 1:
+						{
+							result = source[0];
+							break;
+						}
+						case 2:
+						{
+							result = BinaryPrimitives.ReadUInt16LittleEndian(source);
+							break;
+						}
+						default: // 3
+						{
+							result = BinaryPrimitives.ReadUInt16LittleEndian(source);
+							source = source.Slice(2);
+							result |= (uint)(source[0] << 16);
+							break;
+						}
+					}
+				}
+
+				source = ReadOnlySpan<byte>.Empty;
+				return result;
 			}
 		}
+#endif
 	}
 }
diff --git a/src/MsgPack.Core/System.Text/Throw.cs b/src/MsgPack.Core/System.Text/Throw.cs
new file mode 100644
index 000000000..07a723adf
--- /dev/null
+++ b/src/MsgPack.Core/System.Text/Throw.cs
@@ -0,0 +1,14 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack;
+
+namespace System.Text
+{
+	internal static class Throw
+	{
+		public static void TooLargeByteLengthForString(string encodingName)
+			=> throw new MessageTypeException($"Input is too large for encoding '{encodingName}' to decode.");
+	}
+}
diff --git a/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs b/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs
index 8d09c4f33..db6aa493e 100644
--- a/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs
+++ b/src/MsgPack.Json/Json/FlexibleJsonDecoder.ReadTrivia.cs
@@ -2,16 +2,37 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using System;
 using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
 
 namespace MsgPack.Json
 {
 	internal partial class FlexibleJsonDecoder
 	{
-		protected override void ReadTrivia(in SequenceReader<byte> source, out ReadOnlySequence<byte> trivia)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected sealed override long ReadTrivia(ref SequenceReader<byte> source)
 		{
-			var offset = source.Consumed;
-			var singleByteWhitespaces = (this.Options.ParseOptions & JsonParseOptions.AllowUnicodeWhitespace) == 0 ? JsonTriviaTokens.StandardWhitespaces : JsonTriviaTokens.SingleByteUnicodeWhitespaces;
+			ReadOnlySpan<byte> singleByteWhitespaces;
+			unsafe
+			{
+				if ((this.Options.ParseOptions & JsonParseOptions.AllowUnicodeWhitespace) == 0)
+				{
+					byte* pStandardWhitespaces = stackalloc byte[] { (byte)' ', (byte)'\t', (byte)'\r', (byte)'\n' };
+					singleByteWhitespaces = new ReadOnlySpan<byte>(pStandardWhitespaces, 4);
+				}
+				else
+				{
+					byte* pSingleByteUnicodeWhitespaces =
+						stackalloc byte[]
+						{
+							(byte)' ', (byte)'\t', (byte)'\r', (byte)'\n',
+							(byte)'\u000B', (byte)'\u000C'
+						};
+					singleByteWhitespaces = new ReadOnlySpan<byte>(pSingleByteUnicodeWhitespaces, 6);
+				}
+			}
 
 			var consumed = 0L;
 			while (!source.End)
@@ -36,7 +57,7 @@ protected override void ReadTrivia(in SequenceReader<byte> source, out ReadOnlyS
 				}
 			}
 
-			trivia = source.Sequence.Slice(offset, consumed);
+			return consumed;
 		}
 
 		private bool TryReadMultiByteUnicodeWhitespaces(in SequenceReader<byte> source, ref long consumed)
@@ -61,10 +82,20 @@ private bool TryReadMultiByteUnicodeWhitespaces(in SequenceReader<byte> source,
 
 		private bool TryReadSingleLineComment(in SequenceReader<byte> source, ref long consumed)
 		{
+			ReadOnlySpan<byte> singleLineCommentStart;
+			ReadOnlySpan<byte> newLine;
+			unsafe
+			{
+				byte* pSingleLineCommentStart = stackalloc[] { (byte)'/', (byte)'/' };
+				singleLineCommentStart = new ReadOnlySpan<byte>(pSingleLineCommentStart, 2);
+				byte* pNewLine = stackalloc[] { (byte)'\r', (byte)'\n' };
+				newLine = new ReadOnlySpan<byte>(pNewLine, 2);
+			}
+
 			if (((this.Options.ParseOptions & JsonParseOptions.AllowHashSingleLineComment) != 0 && source.IsNext((byte)'#', advancePast: true))
-				|| ((this.Options.ParseOptions & JsonParseOptions.AllowDoubleSolidousSingleLineComment) != 0 && source.IsNext(JsonTriviaTokens.SingleLineCommentStart2, advancePast: true)))
+				|| ((this.Options.ParseOptions & JsonParseOptions.AllowDoubleSolidousSingleLineComment) != 0 && source.IsNext(singleLineCommentStart, advancePast: true)))
 			{
-				if (!source.TryReadToAny(out ReadOnlySequence<byte> line, JsonTriviaTokens.NewLine, advancePastDelimiter: true))
+				if (!source.TryReadToAny(out ReadOnlySequence<byte> line, newLine, advancePastDelimiter: true))
 				{
 					// to EoF
 					consumed += source.Remaining;
@@ -73,7 +104,7 @@ private bool TryReadSingleLineComment(in SequenceReader<byte> source, ref long c
 				}
 
 				consumed += line.Length;
-				consumed += source.AdvancePastAny(JsonTriviaTokens.NewLine);
+				consumed += source.AdvancePastAny((byte)'\r', (byte)'\n');
 				return true;
 			}
 
@@ -82,14 +113,29 @@ private bool TryReadSingleLineComment(in SequenceReader<byte> source, ref long c
 
 		private bool TryReadMultiLineComment(in SequenceReader<byte> source, ref long consumed)
 		{
+			if((this.Options.ParseOptions & JsonParseOptions.AllowMultilineComment) == 0)
+			{
+				return false;
+			}
+
+			ReadOnlySpan<byte> multiLineCommentStart;
+			ReadOnlySpan<byte> multiLineCommentEnd;
+			unsafe
+			{
+				byte* pMultiLineCommentStart = stackalloc[] { (byte)'/', (byte)'*' };
+				multiLineCommentStart = new ReadOnlySpan<byte>(pMultiLineCommentStart, 2);
+				byte* pMultiLineCommentEnd = stackalloc[] { (byte)'*', (byte)'/' };
+				multiLineCommentEnd = new ReadOnlySpan<byte>(pMultiLineCommentEnd, 2);
+			}
+
 			var offset = source.Consumed;
 
-			if ((this.Options.ParseOptions & JsonParseOptions.AllowMultilineComment) == 0 || !source.IsNext(JsonTriviaTokens.MultiLineCommentStart, advancePast: true))
+			if (!source.IsNext(multiLineCommentStart, advancePast: true))
 			{
 				return false;
 			}
 
-			if (!source.TryReadToAny(out ReadOnlySequence<byte> comment, JsonTriviaTokens.MultiLineCommentEnd, advancePastDelimiter: true))
+			if (!source.TryReadToAny(out ReadOnlySequence<byte> comment, multiLineCommentEnd, advancePastDelimiter: true))
 			{
 				// */ is not found.
 				source.Rewind(2);
diff --git a/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs b/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs
index 23bc34bcc..b7f4c4b3b 100644
--- a/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs
+++ b/src/MsgPack.Json/Json/FlexibleJsonDecoder.cs
@@ -2,7 +2,10 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using System;
 using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
 
 namespace MsgPack.Json
 {
@@ -14,19 +17,36 @@ internal sealed partial class FlexibleJsonDecoder : JsonDecoder
 		public FlexibleJsonDecoder(JsonDecoderOptions options)
 			: base(options) { }
 
-		protected override bool TryReadNull(in SequenceReader<byte> source)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override unsafe bool TryDecodeNull(ref SequenceReader<byte> source, out int requestHint)
 		{
-			if (source.IsNext(JsonTokens.Null, advancePast: true))
+			byte* pNull= stackalloc byte[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
+			ReadOnlySpan<byte> @null = new ReadOnlySpan<byte>(pNull, 4);
+
+			if (source.IsNext(@null, advancePast: true))
 			{
+				requestHint = 0;
+				source.Advance(4);
 				return true;
 			}
 
+			return this.TryDecodeNullSlow(ref source, out requestHint);
+		}
+
+		private unsafe bool TryDecodeNullSlow(ref SequenceReader<byte> source, out int requestHint)
+		{
+			byte* pUndefined = stackalloc byte[] { (byte)'u', (byte)'n', (byte)'d', (byte)'e', (byte)'f', (byte)'i', (byte)'n', (byte)'e', (byte)'d', };
+			ReadOnlySpan<byte> undefined = new ReadOnlySpan<byte>(pUndefined, 9);
+
 			if ((this.Options.ParseOptions & JsonParseOptions.AllowUndefined) != 0
-				&& source.IsNext(JsonTokens.Undefined, advancePast: true))
+				&& source.IsNext(undefined, advancePast: true))
 			{
+				requestHint = 0;
+				source.Advance(9);
 				return true;
 			}
 
+			requestHint = Math.Max(0, 4 - (int)source.Remaining);
 			return false;
 		}
 	}
diff --git a/src/MsgPack.Json/Json/JsonCharactor.cs b/src/MsgPack.Json/Json/JsonCharactor.cs
index 3c06d41f1..777c447f7 100644
--- a/src/MsgPack.Json/Json/JsonCharactor.cs
+++ b/src/MsgPack.Json/Json/JsonCharactor.cs
@@ -18,5 +18,6 @@ internal static class JsonCharactor
 		public static readonly ReadOnlyMemory<Rune> ShouldBeEscaped = new[] { (byte)'/', (byte)'\'', (byte)'<', (byte)'>', (byte)'&' }.Select(b => new Rune(b)).ToArray(); // For HTML embedding
 		public static ReadOnlySpan<byte> CarriageReturn => new[] { (byte)'\r' };
 		public static ReadOnlySpan<byte> LineFeed => new[] { (byte)'\n' };
+		public static ReadOnlySpan<byte> Tab => new[] { (byte)'\t' };
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs b/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
index cd72d8a69..c5f94307c 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
@@ -2,7 +2,6 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
-using System;
 using System.Buffers;
 using MsgPack.Internal;
 
@@ -10,13 +9,13 @@ namespace MsgPack.Json
 {
 	public partial class JsonDecoder
 	{
-		public override CollectionType DecodeArrayOrMapHeader(in SequenceReader<byte> source, out long itemsCount, out int requestHint)
+		public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount, out int requestHint)
 			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out itemsCount, out requestHint);
 
-		public override long DecodeArrayHeader(in SequenceReader<byte> source, out int requestHint)
+		public sealed override long DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint)
 			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out requestHint);
 
-		public override long DecodeMapHeader(in SequenceReader<byte> source, out int requestHint)
+		public sealed override long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint)
 			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out requestHint);
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs b/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
index aca36b59e..9fe873247 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
@@ -15,26 +15,35 @@ namespace MsgPack.Json
 {
 	public partial class JsonDecoder
 	{
-		public override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default)
+		public sealed override bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default)
 		{
-			this.ReadTrivia(source, out var trivia);
-			if (!trivia.IsEmpty)
+			var startPosition = source.Position;
+			var triviaLength = this.ReadTrivia(ref source);
+			if (triviaLength != 0)
 			{
-				result = DecodeItemResult.ScalarOrSequence(ElementType.OtherTrivia, trivia);
+				result = DecodeItemResult.ScalarOrSequence(ElementType.OtherTrivia, source.Sequence.Slice(startPosition, source.Position));
 				return true;
 			}
 
-			if (!this.TryPeek(source, out var token))
+			if (!source.TryPeek(out var token))
 			{
 				result = DecodeItemResult.InsufficientInput(1);
 				return false;
 			}
 
+#warning HANDLE :/= and ,
 			switch (token)
 			{
 				case (byte)'t':
 				{
-					if (source.IsNext(JsonTokens.True, advancePast: true))
+					ReadOnlySpan<byte> @true;
+					unsafe
+					{
+						byte* pTrue = stackalloc byte[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e' };
+						@true = new ReadOnlySpan<byte>(pTrue, 4);
+					}
+
+					if (source.IsNext(@true, advancePast: true))
 					{
 						result = DecodeItemResult.True();
 						return true;
@@ -44,7 +53,14 @@ public override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemRe
 				}
 				case (byte)'f':
 				{
-					if (source.IsNext(JsonTokens.False, advancePast: true))
+					ReadOnlySpan<byte> @false;
+					unsafe
+					{
+						byte* pFalse = stackalloc byte[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e' };
+						@false = new ReadOnlySpan<byte>(pFalse, 5);
+					}
+
+					if (source.IsNext(@false, advancePast: true))
 					{
 						result = DecodeItemResult.False();
 						return true;
@@ -54,7 +70,14 @@ public override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemRe
 				}
 				case (byte)'n':
 				{
-					if (source.IsNext(JsonTokens.Null, advancePast: true))
+					ReadOnlySpan<byte> @null;
+					unsafe
+					{
+						byte* pNull = stackalloc byte[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
+						@null = new ReadOnlySpan<byte>(pNull, 4);
+					}
+
+					if (source.IsNext(@null, advancePast: true))
 					{
 						result = DecodeItemResult.Null();
 						return true;
@@ -75,7 +98,7 @@ public override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemRe
 				case (byte)'-':
 				case (byte)'+':
 				{
-					var number = this.DecodeNumber(source, out var requestHint);
+					var number = this.DecodeNumber(ref source, out var requestHint);
 					if(requestHint != 0)
 					{
 						result = DecodeItemResult.InsufficientInput(requestHint);
@@ -108,7 +131,7 @@ public override bool DecodeItem(in SequenceReader<byte> source, out DecodeItemRe
 				}
 				case (byte)'"':
 				{
-					if (this.GetRawStringCore(source, out var rawString, out var requestHint))
+					if (this.GetRawStringCore(ref source, out var rawString, out var requestHint))
 					{
 						result = DecodeItemResult.InsufficientInput(requestHint);
 						return false;
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs b/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs
index bd8458d2b..82e84a498 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.Iteration.cs
@@ -4,6 +4,7 @@
 
 using System.Buffers;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using MsgPack.Internal;
 
 namespace MsgPack.Json
@@ -25,7 +26,7 @@ public ArrayIterator(JsonDecoder decoder)
 				this._state = State.Head;
 			}
 
-			public bool DetectArrayEnds(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
+			public bool DetectArrayEnds(ref SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
 			{
 				if (this._state == State.Tail)
 				{
@@ -33,7 +34,7 @@ public bool DetectArrayEnds(in SequenceReader<byte> source, ref long nextItemInd
 					return true; // End
 				}
 
-				this._decoder.ReadTrivia(source, out _);
+				this._decoder.ReadTrivia(ref source);
 
 				switch (this._state)
 				{
@@ -92,7 +93,7 @@ public bool DetectArrayEnds(in SequenceReader<byte> source, ref long nextItemInd
 				} // swtich (this._state)
 
 				// Handle 'maybe item' state
-				this._decoder.ReadTrivia(source, out _);
+				this._decoder.ReadTrivia(ref source);
 				if (!source.TryPeek(out var mayBeArrayEnd))
 				{
 					requestHint = 1;
@@ -141,7 +142,7 @@ public ObjectPropertyIterator(JsonDecoder decoder)
 				this._isEqualSignAllowed = (decoder.Options.ParseOptions & JsonParseOptions.AllowEqualSignSeparator) != 0;
 			}
 
-			public bool DetectObjectEnds(in SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
+			public bool DetectObjectEnds(ref SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint)
 			{
 				if (this._state == State.Tail)
 				{
@@ -149,7 +150,7 @@ public bool DetectObjectEnds(in SequenceReader<byte> source, ref long nextItemIn
 					return true; // End
 				}
 
-				this._decoder.ReadTrivia(source, out _);
+				this._decoder.ReadTrivia(ref source);
 
 				switch (this._state)
 				{
@@ -246,7 +247,7 @@ public bool DetectObjectEnds(in SequenceReader<byte> source, ref long nextItemIn
 				} // swtich (this._state)
 
 				// Handle 'maybe key' state
-				this._decoder.ReadTrivia(source, out _);
+				this._decoder.ReadTrivia(ref source);
 				if (!source.TryPeek(out var mayBeArrayEnd))
 				{
 					requestHint = 1;
@@ -277,11 +278,12 @@ private enum State
 			}
 		}
 
-		public override CollectionType DecodeArrayOrMap(in SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override CollectionType DecodeArrayOrMap(ref SequenceReader<byte> source, out CollectionItemIterator iterator, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
+			this.ReadTrivia(ref source);
 
-			if (!this.TryPeek(source, out var token))
+			if (!source.TryPeek(out var token))
 			{
 				requestHint = 1;
 				iterator = default;
@@ -301,10 +303,26 @@ public override CollectionType DecodeArrayOrMap(in SequenceReader<byte> source,
 					iterator = this.CreateObjectPropertyIterator();
 					return CollectionType.Map;
 				}
+				case (byte)'n':
+				{
+					iterator = default;
+
+					if (this.TryDecodeNull(ref source, out requestHint))
+					{
+						return CollectionType.Null;
+					}
+
+					if (requestHint != 0)
+					{
+						return CollectionType.None;
+					}
+
+					goto default;
+				}
 				default:
 				{
 					var offset = source.Consumed;
-					var kind = TryGetUtf8Unit(source, out var sequence);
+					var kind = TryGetUtf8Unit(ref source, out var sequence);
 					if (kind == Utf8UnitStatus.Valid)
 					{
 						JsonThrow.IsNotArrayNorObject(sequence, offset);
@@ -327,9 +345,10 @@ private CollectionItemIterator CreateArrayIterator()
 		private CollectionItemIterator CreateObjectPropertyIterator()
 			=> new CollectionItemIterator(new ObjectPropertyIterator(this).DetectObjectEnds, -1);
 
-		public override CollectionItemIterator DecodeArray(in SequenceReader<byte> source, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override CollectionItemIterator DecodeArray(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var type = this.DecodeArrayOrMap(source, out var iterator, out requestHint);
+			var type = this.DecodeArrayOrMap(ref source, out var iterator, out requestHint);
 			if (requestHint != 0)
 			{
 				return default;
@@ -343,9 +362,10 @@ public override CollectionItemIterator DecodeArray(in SequenceReader<byte> sourc
 			return iterator;
 		}
 
-		public override CollectionItemIterator DecodeMap(in SequenceReader<byte> source, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override CollectionItemIterator DecodeMap(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var type = this.DecodeArrayOrMap(source, out var iterator, out requestHint);
+			var type = this.DecodeArrayOrMap(ref source, out var iterator, out requestHint);
 			if (requestHint != 0)
 			{
 				return default;
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs b/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs
index bfe6936b5..6351dfc13 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.Nullables.cs
@@ -17,156 +17,156 @@ partial class JsonDecoder
 	{
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Byte? DecodeNullableByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Byte? DecodeNullableByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeByteCore(source, out requestHint);
+			return this.DecodeByteCore(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override SByte? DecodeNullableSByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override SByte? DecodeNullableSByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeSByteCore(source, out requestHint);
+			return this.DecodeSByteCore(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int16? DecodeNullableInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int16? DecodeNullableInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeInt16Core(source, out requestHint);
+			return this.DecodeInt16Core(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt16? DecodeNullableUInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt16? DecodeNullableUInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeUInt16Core(source, out requestHint);
+			return this.DecodeUInt16Core(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int32? DecodeNullableInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int32? DecodeNullableInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeInt32Core(source, out requestHint);
+			return this.DecodeInt32Core(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt32? DecodeNullableUInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt32? DecodeNullableUInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeUInt32Core(source, out requestHint);
+			return this.DecodeUInt32Core(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int64? DecodeNullableInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int64? DecodeNullableInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeInt64Core(source, out requestHint);
+			return this.DecodeInt64Core(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt64? DecodeNullableUInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt64? DecodeNullableUInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeUInt64Core(source, out requestHint);
+			return this.DecodeUInt64Core(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Single? DecodeNullableSingle(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Single? DecodeNullableSingle(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeSingleCore(source, out requestHint);
+			return this.DecodeSingleCore(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Double? DecodeNullableDouble(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Double? DecodeNullableDouble(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeDoubleCore(source, out requestHint);
+			return this.DecodeDoubleCore(ref source, out requestHint);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Boolean? DecodeNullableBoolean(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Boolean? DecodeNullableBoolean(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeBooleanCore(source, out requestHint);
+			return this.DecodeBooleanCore(ref source, out requestHint);
 		}
 
 	}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt b/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt
index c630c16c1..ce9e49b17 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt
+++ b/src/MsgPack.Json/Json/JsonDecoder.Nullables.tt
@@ -38,16 +38,16 @@ foreach (var type in
 #>
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override <#= type #>? DecodeNullable<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		public sealed override <#= type #>? DecodeNullable<#= type #>(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.Decode<#= type #>Core(source, out requestHint);
+			return this.Decode<#= type #>Core(ref source, out requestHint);
 		}
 
 <#
diff --git a/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs b/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs
index 02c905620..d2d0b8f13 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.NumberCore.cs
@@ -6,36 +6,51 @@
 using System.Buffers;
 using System.Buffers.Text;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
 
 namespace MsgPack.Json
 {
 	public partial class JsonDecoder
 	{
-		public override bool DecodeBoolean(in SequenceReader<byte> source, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override bool DecodeBoolean(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeBooleanCore(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeBooleanCore(ref source, out requestHint);
 		}
 
-		private bool DecodeBooleanCore(in SequenceReader<byte> source, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private bool DecodeBooleanCore(ref SequenceReader<byte> source, out int requestHint)
 		{
+			ReadOnlySpan<byte> @true;
+			ReadOnlySpan<byte> @false;
+			unsafe
+			{
+				byte* pTrue = stackalloc byte[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e', };
+				@true = new ReadOnlySpan<byte>(pTrue, 4);
+				byte* pFalse = stackalloc byte[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e', };
+				@false = new ReadOnlySpan<byte>(pFalse, 5);
+			}
+
 			requestHint = 0;
-			if (source.IsNext(JsonTokens.True, advancePast: true))
+			if (source.IsNext(@true, advancePast: true))
 			{
 				return true;
 			}
-			else if (source.IsNext(JsonTokens.False, advancePast: true))
+			else if (source.IsNext(@false, advancePast: true))
 			{
 				return false;
 			}
 			else
 			{
-				requestHint = GetRequestHintForBoolean(source);
+				requestHint = GetRequestHintForBoolean(ref source);
 				return default;
 			}
 		}
 
-		private static int GetRequestHintForBoolean(in SequenceReader<byte> source)
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static int GetRequestHintForBoolean(ref SequenceReader<byte> source)
 		{
 			if (!source.TryPeek(out var b))
 			{
@@ -46,43 +61,52 @@ private static int GetRequestHintForBoolean(in SequenceReader<byte> source)
 			{
 				case (byte)'t':
 				{
-					return GetRequestHintForBoolean(source, offset: 1, JsonTokens.True);
+					ReadOnlySpan<byte> @true;
+					unsafe
+					{
+						byte* pTrue = stackalloc byte[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e' };
+						@true = new ReadOnlySpan<byte>(pTrue, 4);
+					}
+
+					return GetRequestHintForBoolean(ref source, offset: 1, @true);
 				}
 				case (byte)'f':
 				{
-					return GetRequestHintForBoolean(source, offset: 1, JsonTokens.False);
+					ReadOnlySpan<byte> @false;
+					unsafe
+					{
+						byte* pFalse = stackalloc byte[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e' };
+						@false = new ReadOnlySpan<byte>(pFalse, 5);
+					}
+
+					return GetRequestHintForBoolean(ref source, offset: 1, @false);
 				}
 			}
 
-			ThrowNonBooleanUtfSequence(source, source.Consumed);
+			ThrowNonBooleanUtfSequence(ref source, source.Consumed);
 			// never
 			return default;
 		}
 
-		private static int GetRequestHintForBoolean(in SequenceReader<byte> source, int offset, ReadOnlySpan<byte> expected)
+		private static int GetRequestHintForBoolean(ref SequenceReader<byte> source, int offset, ReadOnlySpan<byte> expected)
 		{
-			var subReeader = new SequenceReader<byte>(source.Sequence.Slice(source.Consumed + 1));
+			Span<byte> buffer = stackalloc byte[(int)Math.Min(expected.Length, source.Remaining)];
+			source.TryCopyTo(buffer);
 
-			for (int i = 0; i < expected.Length; i++)
+			for (var i = 0; i < buffer.Length; i++)
 			{
-				if (!subReeader.TryRead(out var b))
-				{
-					return expected.Length - i;
-				}
-
-				if (b != expected[i])
+				if (buffer[i] != expected[i])
 				{
-					ThrowNonBooleanUtfSequence(subReeader, subReeader.Consumed + source.Consumed);
+					ThrowNonBooleanUtfSequence(ref source, source.Consumed + i);
 				}
 			}
 
-			Debug.Fail("should be true/false...");
-			return default;
+			return expected.Length - buffer.Length;
 		}
 
-		private static void ThrowNonBooleanUtfSequence(in SequenceReader<byte> source, long position)
+		private static void ThrowNonBooleanUtfSequence(ref SequenceReader<byte> source, long position)
 		{
-			if (TryGetUtf8Unit(source, out var unit) == Utf8UnitStatus.Invalid)
+			if (TryGetUtf8Unit(ref source, out var unit) == Utf8UnitStatus.Invalid)
 			{
 				JsonThrow.MalformedUtf8(unit, position);
 			}
@@ -92,92 +116,117 @@ private static void ThrowNonBooleanUtfSequence(in SequenceReader<byte> source, l
 			}
 		}
 
-		private double DecodeNumber(in SequenceReader<byte> source, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private double DecodeNumber(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var start = source.Position;
-			var startOffset = source.Consumed;
+			var lengthReader = source;
+			ReadOnlySpan<byte> plusMinusSigns;
+			ReadOnlySpan<byte> nonZeroDigits;
+			ReadOnlySpan<byte> digits;
+			unsafe
+			{
+				byte* pPlusMinusSigns = stackalloc[] { (byte)'+', (byte)'-' };
+				plusMinusSigns = new ReadOnlySpan<byte>(pPlusMinusSigns, 2);
+				byte* pDigits = stackalloc[] { (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9' };
+				digits = new ReadOnlySpan<byte>(pDigits, 9);
+				nonZeroDigits = digits.Slice(1);
+			}
+
 			var length = 0L;
 			// -? (0 | [1-9] \d*) (\. \d+ ([eE] [+-] \d+)? )?
 			// sign
-			if (source.IsNext(JsonNumberTokens.PlusMinusSigns, advancePast: true))
-			{
-				length++;
-			}
+			length += lengthReader.AdvancePastAny((byte)'+', (byte)'-');
 
 			// 0
-			if (source.IsNext((byte)'0', advancePast: true))
+			if (lengthReader.IsNext((byte)'0', advancePast: true))
 			{
 				length++;
 			}
 			// [1-9]
-			else if (source.IsNext(JsonNumberTokens.NonZeroDigits, advancePast: true))
-			{
-				length++;
-				// \d*
-				length += source.AdvancePastAny(JsonNumberTokens.Digits);
-			}
 			else
 			{
-				ThrowInvalidNumber(source);
+				var nonZeroLength = lengthReader.AdvancePastAny(nonZeroDigits);
+				if (nonZeroLength > 0)
+				{
+					length += nonZeroLength;
+					// \d*
+					length += lengthReader.AdvancePastAny(digits);
+				}
+				else
+				{
+					ThrowInvalidNumber(ref lengthReader);
+				}
 			}
 
 			// Check early for integer portion.
 			if (length > this.Options.MaxNumberLengthInBytes)
 			{
-				JsonThrow.TooLongNumber(length, this.Options.MaxNumberLengthInBytes, startOffset);
+				JsonThrow.TooLongNumber(length, this.Options.MaxNumberLengthInBytes, source.Consumed);
 			}
 
 			// (\. ...)?
-			if (source.IsNext((byte)'.', advancePast: true))
+			if (lengthReader.IsNext((byte)'.', advancePast: true))
 			{
 				length++;
 
-				if (source.End)
+				if (lengthReader.End)
 				{
 					requestHint = 1;
-					source.Rewind(length);
 					return default;
 				}
 
 				// \d+
-				length += ReadAtLeastOneDigits(source, out requestHint);
+				length += ReadAtLeastOneDigits(ref lengthReader, digits, out requestHint);
 				if (requestHint != 0)
 				{
-					source.Rewind(length);
 					return default;
 				}
 
+				ReadOnlySpan<byte> exponentialIndicators;
+				unsafe
+				{
+					byte* pExponentialIndicators = stackalloc byte[] { (byte)'E', (byte)'e' };
+					exponentialIndicators = new ReadOnlySpan<byte>(pExponentialIndicators, 2);
+				}
+
 				// ([eE] ..)?
-				if (source.IsNext(JsonNumberTokens.ExponentialIndicators, advancePast: true))
+				if (lengthReader.IsNext(exponentialIndicators, advancePast: true))
 				{
 					// [+-]
-					if (source.IsNext(JsonNumberTokens.PlusMinusSigns, advancePast: true))
+					if (lengthReader.IsNext(plusMinusSigns, advancePast: true))
 					{
 						// \d+
-						length += ReadAtLeastOneDigits(source, out requestHint);
+						length += ReadAtLeastOneDigits(ref lengthReader, digits, out requestHint);
 						if (requestHint != 0)
 						{
-							source.Rewind(length);
 							return default;
 						}
 					}
 					else
 					{
-						ThrowInvalidNumber(source);
+						ThrowInvalidNumber(ref lengthReader);
 					}
 				}
 			}
 
 			if (length > this.Options.MaxNumberLengthInBytes)
 			{
-				JsonThrow.TooLongNumber(length, this.Options.MaxNumberLengthInBytes, startOffset);
+				JsonThrow.TooLongNumber(length, this.Options.MaxNumberLengthInBytes, source.Consumed);
 			}
 
-			var readDirect = source.UnreadSpan.Length <= length;
+			if (source.UnreadSpan.Length >= length)
+			{
+				var shouldBeTrue = Utf8Parser.TryParse(source.UnreadSpan, out double result, out var consumed);
+				Debug.Assert(shouldBeTrue, "Utf8Parser.TryParse returns false!");
+				Debug.Assert(consumed == length, $"Utf8Parser.TryParse outputs ({consumed}:#,0) is not {length:#,0}!");
+				source.Advance(consumed);
+				requestHint = 0;
+				return result;
+			}
 
 			var length32 = (int)length;
 			byte[]? arrayBuffer = default;
-			if (!readDirect && length > 32)
+			if (length > 32)
 			{
 				// length should be Int32 because MaxNumberLength is Int32 type.
 				arrayBuffer = this.Options.ByteBufferPool.Rent(length32);
@@ -185,17 +234,14 @@ private double DecodeNumber(in SequenceReader<byte> source, out int requestHint)
 
 			try
 			{
-				Span<byte> buffer =
-					readDirect ?
-						default :
-						arrayBuffer ?? (stackalloc byte[length32]);
-				var number = GetSpan(source.Sequence.Slice(start, length32), buffer);
+				Span<byte> buffer = arrayBuffer ?? (stackalloc byte[length32]);
+				source.TryCopyTo(buffer);
 
-				var shouldBeTrue = Utf8Parser.TryParse(number, out double result, out var shouldBeLength);
+				var shouldBeTrue = Utf8Parser.TryParse(buffer, out double result, out var consumed);
 				Debug.Assert(shouldBeTrue, "Utf8Parser.TryParse returns false!");
-				Debug.Assert(shouldBeLength == length, $"Utf8Parser.TryParse outputs ({shouldBeLength}:#,0) is not {length:#,0}!");
+				Debug.Assert(consumed == length, $"Utf8Parser.TryParse outputs ({consumed}:#,0) is not {length:#,0}!");
+				source.Advance(consumed);
 				requestHint = 0;
-				source.Advance(length);
 				return result;
 			}
 			finally
@@ -207,20 +253,8 @@ private double DecodeNumber(in SequenceReader<byte> source, out int requestHint)
 			}
 		}
 
-		private static ReadOnlySpan<byte> GetSpan(in ReadOnlySequence<byte> source, Span<byte> buffer)
-		{
-			if (source.IsSingleSegment)
-			{
-				Debug.Assert(source.FirstSpan.Length == source.Length, "source.FirstSpan.Length == source.Length");
-				return source.FirstSpan;
-			}
-
-			Debug.Assert(source.Length == buffer.Length, "source.Length == buffer.Length");
-			source.CopyTo(buffer);
-			return buffer;
-		}
-
-		private static long ReadAtLeastOneDigits(in SequenceReader<byte> source, out int requestHint)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static long ReadAtLeastOneDigits(ref SequenceReader<byte> source, ReadOnlySpan<byte> digits, out int requestHint)
 		{
 			if (source.End)
 			{
@@ -228,20 +262,21 @@ private static long ReadAtLeastOneDigits(in SequenceReader<byte> source, out int
 				return default;
 			}
 
-			var decimalLength = source.AdvancePastAny(JsonNumberTokens.Digits);
+			var decimalLength = source.AdvancePastAny(digits);
 			if (decimalLength == 0)
 			{
-				ThrowInvalidNumber(source);
+				ThrowInvalidNumber(ref source);
 			}
 
 			requestHint = 0;
 			return decimalLength;
 		}
 
-		private static void ThrowInvalidNumber(in SequenceReader<byte> source)
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static void ThrowInvalidNumber(ref SequenceReader<byte> source)
 		{
 			var position = source.Consumed;
-			if (TryGetUtf8Unit(source, out var unit) == Utf8UnitStatus.Valid)
+			if (TryGetUtf8Unit(ref source, out var unit) == Utf8UnitStatus.Valid)
 			{
 				JsonThrow.IsNotType(typeof(double), unit, position);
 			}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs b/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs
index 1eff27f97..0be7af301 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.Numbers.cs
@@ -17,123 +17,123 @@ partial class JsonDecoder
 	{
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Byte DecodeByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Byte DecodeByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeByteCore(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeByteCore(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private Byte DecodeByteCore(in SequenceReader<byte> source, out int requestHint)
-			=> (Byte)this.DecodeNumber(source, out requestHint);
+		private Byte DecodeByteCore(ref SequenceReader<byte> source, out int requestHint)
+			=> (Byte)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override SByte DecodeSByte(in SequenceReader<byte> source, out int requestHint)
+		public sealed override SByte DecodeSByte(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeSByteCore(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeSByteCore(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private SByte DecodeSByteCore(in SequenceReader<byte> source, out int requestHint)
-			=> (SByte)this.DecodeNumber(source, out requestHint);
+		private SByte DecodeSByteCore(ref SequenceReader<byte> source, out int requestHint)
+			=> (SByte)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int16 DecodeInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int16 DecodeInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeInt16Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeInt16Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private Int16 DecodeInt16Core(in SequenceReader<byte> source, out int requestHint)
-			=> (Int16)this.DecodeNumber(source, out requestHint);
+		private Int16 DecodeInt16Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (Int16)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt16 DecodeUInt16(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt16 DecodeUInt16(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeUInt16Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeUInt16Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private UInt16 DecodeUInt16Core(in SequenceReader<byte> source, out int requestHint)
-			=> (UInt16)this.DecodeNumber(source, out requestHint);
+		private UInt16 DecodeUInt16Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (UInt16)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int32 DecodeInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int32 DecodeInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeInt32Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeInt32Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private Int32 DecodeInt32Core(in SequenceReader<byte> source, out int requestHint)
-			=> (Int32)this.DecodeNumber(source, out requestHint);
+		private Int32 DecodeInt32Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (Int32)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt32 DecodeUInt32(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt32 DecodeUInt32(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeUInt32Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeUInt32Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private UInt32 DecodeUInt32Core(in SequenceReader<byte> source, out int requestHint)
-			=> (UInt32)this.DecodeNumber(source, out requestHint);
+		private UInt32 DecodeUInt32Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (UInt32)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Int64 DecodeInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Int64 DecodeInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeInt64Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeInt64Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private Int64 DecodeInt64Core(in SequenceReader<byte> source, out int requestHint)
-			=> (Int64)this.DecodeNumber(source, out requestHint);
+		private Int64 DecodeInt64Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (Int64)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override UInt64 DecodeUInt64(in SequenceReader<byte> source, out int requestHint)
+		public sealed override UInt64 DecodeUInt64(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeUInt64Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeUInt64Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private UInt64 DecodeUInt64Core(in SequenceReader<byte> source, out int requestHint)
-			=> (UInt64)this.DecodeNumber(source, out requestHint);
+		private UInt64 DecodeUInt64Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (UInt64)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Single DecodeSingle(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Single DecodeSingle(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeSingleCore(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeSingleCore(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private Single DecodeSingleCore(in SequenceReader<byte> source, out int requestHint)
-			=> (Single)this.DecodeNumber(source, out requestHint);
+		private Single DecodeSingleCore(ref SequenceReader<byte> source, out int requestHint)
+			=> (Single)this.DecodeNumber(ref source, out requestHint);
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override Double DecodeDouble(in SequenceReader<byte> source, out int requestHint)
+		public sealed override Double DecodeDouble(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeDoubleCore(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.DecodeDoubleCore(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private Double DecodeDoubleCore(in SequenceReader<byte> source, out int requestHint)
-			=> (Double)this.DecodeNumber(source, out requestHint);
+		private Double DecodeDoubleCore(ref SequenceReader<byte> source, out int requestHint)
+			=> (Double)this.DecodeNumber(ref source, out requestHint);
 
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt b/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt
index 70674fd15..5372860bd 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt
+++ b/src/MsgPack.Json/Json/JsonDecoder.Numbers.tt
@@ -37,15 +37,15 @@ foreach (var type in
 #>
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override <#= type #> Decode<#= type #>(in SequenceReader<byte> source, out int requestHint)
+		public sealed override <#= type #> Decode<#= type #>(ref SequenceReader<byte> source, out int requestHint)
 		{
-			this.ReadTrivia(source, out _);
-			return this.Decode<#= type #>Core(source, out requestHint);
+			this.ReadTrivia(ref source);
+			return this.Decode<#= type #>Core(ref source, out requestHint);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private <#= type #> Decode<#= type #>Core(in SequenceReader<byte> source, out int requestHint)
-			=> (<#= type #>)this.DecodeNumber(source, out requestHint);
+		private <#= type #> Decode<#= type #>Core(ref SequenceReader<byte> source, out int requestHint)
+			=> (<#= type #>)this.DecodeNumber(ref source, out requestHint);
 
 <#
 } // foreach (var type)
diff --git a/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs b/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs
index c7c6fb4a5..d45e0c7d5 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.SkipDrain.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -11,14 +11,14 @@ namespace MsgPack.Json
 {
 	public partial class JsonDecoder
 	{
-		public override void Drain(in SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default)
+		public override void Drain(ref SequenceReader<byte> source, in CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken = default)
 			=> JsonThrow.DrainIsNotSupported(out requestHint);
 
-		public override void Skip(in SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default)
+		public override void Skip(ref SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			var originalPosition = source.Consumed;
 
-			if(!this.DecodeItem(source, out var decodeItemResult, cancellationToken))
+			if(!this.DecodeItem(ref source, out var decodeItemResult, cancellationToken))
 			{
 				requestHint = (int)(decodeItemResult.RequestHint & Int32.MaxValue);
 				return;
@@ -30,7 +30,8 @@ public override void Skip(in SequenceReader<byte> source, in CollectionContext c
 				case ElementType.Map:
 				{
 					// Skip current collection with CollectionIterator.Drain()
-					if(!decodeItemResult.CollectionIterator.Drain(source, out requestHint))
+					var iterator = decodeItemResult.CollectionIterator;
+					if (!iterator.Drain(ref source, out requestHint))
 					{
 						source.Rewind(source.Consumed - originalPosition);
 						return;
diff --git a/src/MsgPack.Json/Json/JsonDecoder.Strings.cs b/src/MsgPack.Json/Json/JsonDecoder.Strings.cs
index 616a6f0aa..e728da428 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.Strings.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.Strings.cs
@@ -16,9 +16,10 @@ namespace MsgPack.Json
 	public partial class JsonDecoder
 	{
 		/// <inheritdoc />
-		public override bool GetRawString(in SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override bool GetRawString(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			if (!this.GetRawStringCore(source, out var rawStringSequence, out requestHint, cancellationToken))
+			if (!this.GetRawStringCore(ref source, out var rawStringSequence, out requestHint, cancellationToken))
 			{
 				rawString = default;
 				return false;
@@ -39,105 +40,127 @@ public override bool GetRawString(in SequenceReader<byte> source, out ReadOnlySp
 			return true;
 		}
 
-		private bool GetRawStringCore(in SequenceReader<byte> source, out ReadOnlySequence<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
+		private bool GetRawStringCore(ref SequenceReader<byte> source, out ReadOnlySequence<byte> rawString, out int requestHint, CancellationToken cancellationToken = default)
 		{ 
-			this.ReadTrivia(source, out _);
+			this.ReadTrivia(ref source);
 			var startOffset = source.Consumed;
 
-			var quotation = this.ReadStringStart(source, out var delimiters, out requestHint);
+			var quotation = this.ReadStringStart(ref source, out requestHint);
 			if (requestHint != 0)
 			{
 				rawString = default;
 				return false;
 			}
 
-			var length = 0L;
-			var rawStringStart = source.Position;
-			// We accept unescaped charactors except quotation even if the value is '\0' because we can handle them correctly.
-			while (true)
+			if (!source.TryReadTo(out ReadOnlySequence<byte> sequence, quotation, (byte)'\\', advancePastDelimiter: false))
 			{
-				cancellationToken.ThrowIfCancellationRequested();
-
-				if (!source.TryReadToAny(out ReadOnlySequence<byte> sequence, delimiters, advancePastDelimiter: false))
-				{
-					// EoF
-					requestHint = 1;
-					break;
-				}
-
-				if (sequence.Length + length > this.Options.MaxStringLengthInBytes)
-				{
-					Throw.StringLengthExceeded(source.Consumed - sequence.Length, sequence.Length + length, this.Options.MaxBinaryLengthInBytes);
-				}
-
-				length += (int)sequence.Length;
-
-				// Handle delimiter
-				source.TryRead(out var delimiter);
-				if (delimiter == quotation)
-				{
-					// End
-					requestHint = 0;
-					rawString = source.Sequence.Slice(rawStringStart, length);
-					return true;
-				}
-
-				// Decode escape sequence
-				if (source.End)
-				{
-					// EoF
-					requestHint = 2;
-					break;
-				}
+				// EoF
+				requestHint = 1;
+				rawString = default;
+				source.Rewind(source.Consumed - startOffset);
+				return false;
 			}
 
-			// No closing quotation.
-			rawString = default;
-			source.Rewind(source.Consumed - startOffset);
-			return false;
+			rawString = sequence;
+			source.Advance(1); // skip end quote
+			return true;
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override string? DecodeNullableString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public sealed override string? DecodeNullableString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeStringCore(source, out requestHint, cancellationToken);
+			return this.DecodeStringCore(ref source, out requestHint, cancellationToken);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override string? DecodeString(in SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public sealed override string? DecodeString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeStringCore(source, out requestHint, cancellationToken);
+			this.ReadTrivia(ref source);
+			return this.DecodeStringCore(ref source, out requestHint, cancellationToken);
 		}
 
-		private string? DecodeStringCore(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private string? DecodeStringCore(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			var startOffset = source.Consumed;
 
-			var quotation = this.ReadStringStart(source, out var delimiters, out requestHint);
+			var quotation = this.ReadStringStart(ref source, out requestHint);
 			if (requestHint != 0)
 			{
 				return default;
 			}
 
-			var length = 0L;
+			// fast-path
+			if (!source.TryReadTo(out ReadOnlySequence<byte> sequence, quotation, (byte)'\\', advancePastDelimiter: false) || !source.TryRead(out var delimiter))
+			{
+				// EoF
+				requestHint = 1;
+				source.Rewind(source.Consumed - startOffset);
+				return default;
+			}
+
+			if (sequence.Length > this.Options.MaxStringLengthInBytes)
+			{
+				Throw.StringLengthExceeded(source.Consumed - sequence.Length, sequence.Length, this.Options.MaxBinaryLengthInBytes);
+			}
+
+			if (delimiter == quotation)
+			{
+				return Encoding.UTF8.GetString(sequence);
+			}
+
+			return this.DecodeStringCoreSlow(ref source, out requestHint, startOffset, quotation, ref sequence, delimiter, cancellationToken);
+		}
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private string? DecodeStringCoreSlow(ref SequenceReader<byte> source, out int requestHint, long startOffset, byte quotation, ref ReadOnlySequence<byte> sequence, byte delimiter, CancellationToken cancellationToken)
+		{
+			var length = sequence.Length;
 			using (var result = new StringBuilderBufferWriter(new StringBuilder(), this.Options))
 			{
+				Encoding.UTF8.GetChars(sequence, result);
+				length += (int)sequence.Length;
+
 				// We accept unescaped charactors except quotation even if the value is '\0' because we can handle them correctly.
 				while (true)
 				{
+					// Decode escape sequence
+					if (source.End)
+					{
+						// EoF
+						requestHint = 2;
+						break;
+					}
+
+					if (!source.IsNext((byte)'u', advancePast: true))
+					{
+						DecodeSpetialEscapeSequence(ref source, result);
+						length += 2;
+					}
+					else
+					{
+						DecodeUnicodeEscapceSequence(source, result, out requestHint);
+						if (requestHint != 0)
+						{
+							source.Rewind(source.Consumed - startOffset);
+							return default;
+						}
+
+						length += 6;
+					}
+
 					cancellationToken.ThrowIfCancellationRequested();
 
-					if (!source.TryReadToAny(out ReadOnlySequence<byte> sequence, delimiters, advancePastDelimiter: false))
+					if (!source.TryReadTo(out sequence, quotation, (byte)'\\', advancePastDelimiter: false))
 					{
 						// EoF
 						requestHint = 1;
@@ -155,38 +178,13 @@ private bool GetRawStringCore(in SequenceReader<byte> source, out ReadOnlySequen
 					length += (int)sequence.Length;
 
 					// Handle delimiter
-					source.TryRead(out var delimiter);
+					source.TryRead(out delimiter);
 					if (delimiter == quotation)
 					{
 						// End
 						requestHint = 0;
 						return result.ToString();
 					}
-
-					// Decode escape sequence
-					if (source.End)
-					{
-						// EoF
-						requestHint = 2;
-						break;
-					}
-
-					if (!source.IsNext((byte)'u', advancePast: true))
-					{
-						DecodeSpetialEscapeSequence(source, result);
-						length += 2;
-					}
-					else
-					{
-						DecodeUnicodeEscapceSequence(source, result, out requestHint);
-						if (requestHint != 0)
-						{
-							source.Rewind(source.Consumed - startOffset);
-							return default;
-						}
-
-						length += 6;
-					}
 				}
 			}
 
@@ -194,18 +192,20 @@ private bool GetRawStringCore(in SequenceReader<byte> source, out ReadOnlySequen
 			return default;
 		}
 
-		private byte ReadStringStart(in SequenceReader<byte> source, out ReadOnlySpan<byte> delimiters, out int requestHint)
+		private byte ReadStringStart(ref SequenceReader<byte> source, out int requestHint)
 		{
 			if (source.End)
 			{
 				requestHint = 2;
-				delimiters = default;
 				return default;
 			}
 
+			requestHint = 0;
+
 			if (source.IsNext((byte)'"', advancePast: false))
 			{
-				delimiters = JsonStringTokens.DoubleQuotationDelimiters;
+				source.Advance(1);
+				return (byte)'"';
 			}
 			else
 			{
@@ -214,42 +214,78 @@ private byte ReadStringStart(in SequenceReader<byte> source, out ReadOnlySpan<by
 					// ['"]
 					if (source.IsNext((byte)'\'', advancePast: false))
 					{
-						delimiters = JsonStringTokens.SingleQuotationDelimiters;
+						source.Advance(1);
+						return (byte)'\'';
 					}
 					else
 					{
 						JsonThrow.IsNotStringStart(source.Consumed, JsonStringTokens.AnyQuotations);
 						// never
-						delimiters = default;
+						return default;
 					}
 				}
 				else
 				{
 					JsonThrow.IsNotStringStart(source.Consumed, JsonStringTokens.DoubleQuotation);
 					// never
-					delimiters = default;
+					return default;
 				}
 			}
-
-			source.TryRead(out var quotation);
-			requestHint = 0;
-			return quotation;
 		}
 
-		private static void DecodeSpetialEscapeSequence(in SequenceReader<byte> source, StringBuilderBufferWriter result)
+		private static void DecodeSpetialEscapeSequence(ref SequenceReader<byte> source, StringBuilderBufferWriter result)
 		{
 			source.TryPeek(out var escaped);
-			// Handle known escape sequence
-			var index = escaped - JsonStringTokens.UnescapedCharactorsOffset;
-			var unescaped = Byte.MaxValue;
-			if (index >= 0 && index < JsonStringTokens.UnescapedCharactors.Length)
-			{
-				unescaped = JsonStringTokens.UnescapedCharactors[index];
-			}
-
-			if (unescaped >= 0x80)
+			char unescaped;
+			switch(escaped)
 			{
-				JsonThrow.InvalidEscapeSequence(source.Consumed, escaped);
+				case (byte)'b':
+				{
+					unescaped = '\b';
+					break;
+				}
+				case (byte)'t':
+				{
+					unescaped = '\t';
+					break;
+				}
+				case (byte)'f':
+				{
+					unescaped = '\f';
+					break;
+				}
+				case (byte)'r':
+				{
+					unescaped = '\r';
+					break;
+				}
+				case (byte)'n':
+				{
+					unescaped = '\n';
+					break;
+				}
+				case (byte)'"':
+				{
+					unescaped = '"';
+					break;
+				}
+				case (byte)'\\':
+				{
+					unescaped = '\\';
+					break;
+				}
+				case (byte)'/':
+				{
+					unescaped = '/';
+					break;
+				}
+				default:
+				{
+					JsonThrow.InvalidEscapeSequence(source.Consumed - 1, escaped);
+					// never
+					unescaped = default;
+					break;
+				}
 			}
 
 			result.AppendUtf16CodePoint(unescaped);
@@ -303,7 +339,14 @@ private static void DecodeUnicodeEscapceSequence(SequenceReader<byte> source, St
 					JsonThrow.OrphanSurrogate(positionOf1stSurrogate, codePointOrHighSurrogate);
 				}
 
-				source.Sequence.Slice(source.Consumed, 4).CopyTo(buffer);
+				if(!source.TryCopyTo(buffer))
+				{
+					requestHint = buffer.Length - (int)source.Remaining;
+					return;
+				}
+
+				source.Advance(4);
+
 				if (!Utf8Parser.TryParse(buffer, out int shouldBeLowSurrogate, out consumed, standardFormat: 'X'))
 				{
 					JsonThrow.InvalidUnicodeEscapeSequence(source.Consumed, buffer);
@@ -326,31 +369,31 @@ private static void DecodeUnicodeEscapceSequence(SequenceReader<byte> source, St
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override byte[]? DecodeNullableBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		public sealed override byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			this.ReadTrivia(source, out _);
-			if (this.TryReadNull(source))
+			this.ReadTrivia(ref source);
+			if (this.TryDecodeNull(ref source))
 			{
 				requestHint = 0;
 				return null;
 			}
 
-			return this.DecodeBinaryCore(source, out requestHint, cancellationToken);
+			return this.DecodeBinaryCore(ref source, out requestHint, cancellationToken);
 		}
 
 		/// <inheritdoc />
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override byte[]? DecodeBinary(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		public sealed override byte[]? DecodeBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
 		{
-			this.ReadTrivia(source, out _);
-			return this.DecodeBinaryCore(source, out requestHint, cancellationToken);
+			this.ReadTrivia(ref source);
+			return this.DecodeBinaryCore(ref source, out requestHint, cancellationToken);
 		}
 
-		private byte[]? DecodeBinaryCore(in SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
+		private byte[]? DecodeBinaryCore(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			var startOffset = source.Consumed;
 
-			var quotation = this.ReadStringStart(source, out _, out requestHint);
+			var quotation = this.ReadStringStart(ref source, out requestHint);
 			if (requestHint != 0)
 			{
 				return default;
diff --git a/src/MsgPack.Json/Json/JsonDecoder.cs b/src/MsgPack.Json/Json/JsonDecoder.cs
index 87fc25bf5..aa17d1b2d 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.cs
@@ -43,7 +43,7 @@ public static JsonDecoder Create(JsonDecoderOptions options)
 			}
 		}
 
-		private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> source, out ReadOnlySequence<byte> unit)
+		private protected static Utf8UnitStatus TryGetUtf8Unit(ref SequenceReader<byte> source, out ReadOnlySequence<byte> unit)
 		{
 			if (source.UnreadSpan.IsEmpty)
 			{
@@ -55,7 +55,7 @@ private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> s
 			if ((utf80 & 0b_1000_0000) == 0)
 			{
 				// 1byte
-				unit = source.Sequence.Slice(source.Consumed, 1);
+				unit = source.Sequence.Slice(source.Position, 1);
 				return Utf8UnitStatus.Valid;
 			}
 			else if ((utf80 & 0b_1110_0000) == 0b_1100_0000)
@@ -63,11 +63,11 @@ private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> s
 				Span<byte> utf8 = stackalloc byte[2];
 				if (!source.TryCopyTo(utf8))
 				{
-					unit = source.Sequence.Slice(source.Consumed, source.Remaining);
+					unit = source.Sequence.Slice(source.Position);
 					return Utf8UnitStatus.TooShort;
 				}
 
-				unit = source.Sequence.Slice(source.Consumed, 2);
+				unit = source.Sequence.Slice(source.Position, 2);
 
 				// 2 bytes, 5 + 6 bits
 				var bits1 = utf8[0] & 0b_0001_1111;
@@ -86,11 +86,11 @@ private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> s
 				Span<byte> utf8 = stackalloc byte[3];
 				if (!source.TryCopyTo(utf8))
 				{
-					unit = source.Sequence.Slice(source.Consumed, source.Remaining);
+					unit = source.Sequence.Slice(source.Position);
 					return Utf8UnitStatus.TooShort;
 				}
 
-				unit = source.Sequence.Slice(source.Consumed, 3);
+				unit = source.Sequence.Slice(source.Position, 3);
 
 				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
 					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000)
@@ -117,11 +117,11 @@ private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> s
 				Span<byte> utf8 = stackalloc byte[4];
 				if (!source.TryCopyTo(utf8))
 				{
-					unit = source.Sequence.Slice(source.Consumed, source.Remaining);
+					unit = source.Sequence.Slice(source.Position);
 					return Utf8UnitStatus.TooShort;
 				}
 
-				unit = source.Sequence.Slice(source.Consumed, 4);
+				unit = source.Sequence.Slice(source.Position, 4);
 
 				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
 					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000
@@ -147,14 +147,12 @@ private protected static Utf8UnitStatus TryGetUtf8Unit(in SequenceReader<byte> s
 			}
 			else
 			{
-				unit = source.Sequence.Slice(source.Consumed, 1);
+				unit = source.Sequence.Slice(source.Position, 1);
 				return Utf8UnitStatus.Invalid;
 			}
 		}
 
-		protected abstract void ReadTrivia(in SequenceReader<byte> source, out ReadOnlySequence<byte> trivia);
-
-		protected abstract bool TryReadNull(in SequenceReader<byte> source);
+		protected abstract long ReadTrivia(ref SequenceReader<byte> source);
 
 		protected enum Utf8UnitStatus
 		{
diff --git a/src/MsgPack.Json/Json/JsonDecoderOptions.cs b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
index eb4e36dbc..6ff0dc68e 100644
--- a/src/MsgPack.Json/Json/JsonDecoderOptions.cs
+++ b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
@@ -11,6 +11,8 @@ namespace MsgPack.Json
 	/// </summary>
 	public class JsonDecoderOptions : DecoderOptions
 	{
+		public static JsonDecoderOptions Default { get; } = new JsonDecoderOptionsBuilder().Build();
+
 		public JsonParseOptions ParseOptions { get; }
 
 		public JsonDecoderOptions(JsonDecoderOptionsBuilder builder)
diff --git a/src/MsgPack.Json/Json/JsonEncoder.cs b/src/MsgPack.Json/Json/JsonEncoder.cs
index ab21260ad..d70a1bfa3 100644
--- a/src/MsgPack.Json/Json/JsonEncoder.cs
+++ b/src/MsgPack.Json/Json/JsonEncoder.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Buffers;
 using System.Buffers.Text;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -47,23 +48,15 @@ public JsonEncoder(JsonEncoderOptions options)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static int WriteNull(Span<byte> span)
-		{
-			if (span.Length < 4)
-			{
-				return -1;
-			}
-
-			JsonTokens.Null.CopyTo(span);
-			return 4;
-		}
+		public sealed override void EncodeRawString(ReadOnlySpan<byte> rawString, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+			=> Ensure.NotNull(buffer).Write(rawString);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeInt32(int value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeInt32(int value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			var span = buffer.GetSpan();
+			var span = buffer.GetSpan(11);
 			while (true)
 			{
 				if (!Utf8Formatter.TryFormat(value, span, out var used))
@@ -79,11 +72,11 @@ public override void EncodeInt32(int value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeUInt32(uint value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeUInt32(uint value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			var span = buffer.GetSpan();
+			var span = buffer.GetSpan(10);
 			while (true)
 			{
 				if (!Utf8Formatter.TryFormat(value, span, out var used))
@@ -99,11 +92,11 @@ public override void EncodeUInt32(uint value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeInt64(long value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeInt64(long value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			var span = buffer.GetSpan();
+			var span = buffer.GetSpan(20);
 			while (true)
 			{
 				if (!Utf8Formatter.TryFormat(value, span, out var used))
@@ -119,11 +112,11 @@ public override void EncodeInt64(long value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeUInt64(ulong value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeUInt64(ulong value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			var span = buffer.GetSpan();
+			var span = buffer.GetSpan(19);
 			while (true)
 			{
 				if (!Utf8Formatter.TryFormat(value, span, out var used))
@@ -139,152 +132,186 @@ public override void EncodeUInt64(ulong value, IBufferWriter<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeSingle(float value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeSingle(float value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
-
-			var formatter =
-				Single.IsNaN(value) ?
-				this._singleNanFormatter :
-				Single.IsInfinity(value) ?
-				this._singleInfinityFormatter :
-				JsonFormatter.Format;
-			formatter(value, buffer, this._options);
+			buffer = Ensure.NotNull(buffer);
+
+			if (Single.IsNaN(value))
+			{
+				this._singleNanFormatter(value, buffer, this._options);
+			}
+			else if (Single.IsInfinity(value))
+			{
+				this._singleInfinityFormatter(value, buffer, this._options);
+			}
+			else
+			{
+				JsonFormatter.Format(value, buffer);
+			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeDouble(double value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeDouble(double value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
-
-			var formatter =
-				Double.IsNaN(value) ?
-				this._doubleNanFormatter :
-				Double.IsInfinity(value) ?
-				this._doubleInfinityFormatter :
-				JsonFormatter.Format;
-			formatter(value, buffer, this._options);
+			buffer = Ensure.NotNull(buffer);
+
+			if (Double.IsNaN(value))
+			{
+				this._doubleNanFormatter(value, buffer, this._options);
+			}
+			else if (Double.IsInfinity(value))
+			{
+				this._doubleInfinityFormatter(value, buffer, this._options);
+			}
+			else
+			{
+				JsonFormatter.Format(value, buffer);
+			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeBoolean(bool value, IBufferWriter<byte> buffer)
+		public sealed override void EncodeBoolean(bool value, IBufferWriter<byte> buffer)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			if (value)
 			{
-				buffer.Write(JsonTokens.True);
+				var span = buffer.GetSpan(4);
+				span[0] = (byte)'t';
+				span[1] = (byte)'r';
+				span[2] = (byte)'u';
+				span[3] = (byte)'e';
+				buffer.Advance(4);
 			}
 			else
 			{
-				buffer.Write(JsonTokens.False);
+				var span = buffer.GetSpan(5);
+				span[0] = (byte)'f';
+				span[1] = (byte)'a';
+				span[2] = (byte)'l';
+				span[3] = (byte)'s';
+				span[4] = (byte)'e';
+				buffer.Advance(5);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeNull(IBufferWriter<byte> buffer)
-			=> buffer.Write(JsonTokens.Null);
+		public sealed override void EncodeNull(IBufferWriter<byte> buffer)
+			=> JsonFormatter.WriteNull(Ensure.NotNull(buffer));
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		private void WriteIndent(IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
-
 			if (this._isPrettyPrint)
 			{
-				buffer.Write(this._newLineChars.Span);
-				for (var i = 0; i < collectionContext.CurrentDepth; i++)
-				{
-					buffer.Write(this._indentChars.Span);
-				}
+				this.WriteIndentCore(buffer, collectionContext);
+			}
+		}
+
+		private void WriteIndentCore(IBufferWriter<byte> buffer, CollectionContext collectionContext)
+		{
+			Debug.Assert(buffer != null);
+			buffer.Write(this._newLineChars.Span);
+			for (var i = 0; i < collectionContext.CurrentDepth; i++)
+			{
+				buffer.Write(this._indentChars.Span);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeArrayStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			buffer.Write(JsonTokens.ArrayStart);
-			collectionContext.IncrementDepth();
+			buffer.GetSpan(1)[0] = (byte)'[';
+			buffer.Advance(1);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeArrayEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			collectionContext.DecrementDepth();
 			this.WriteIndent(buffer, collectionContext);
-			buffer.Write(JsonTokens.ArrayEnd);
+			buffer.GetSpan(1)[0] = (byte)']';
+			buffer.Advance(1);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayItemStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeArrayItemStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			this.WriteIndent(buffer, collectionContext);
 			if (index > 0)
 			{
-				buffer.Write(JsonTokens.Comma);
+				buffer.GetSpan(1)[0] = (byte)',';
+				buffer.Advance(1);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeArrayItemEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+		public sealed override void EncodeArrayItemEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeMapStart(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			buffer.Write(JsonTokens.MapStart);
-			collectionContext.IncrementDepth();
+			buffer.GetSpan(1)[0] = (byte)'{';
+			buffer.Advance(1);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeMapEnd(int length, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			collectionContext.DecrementDepth();
 			this.WriteIndent(buffer, collectionContext);
-			buffer.Write(JsonTokens.MapEnd);
+			buffer.GetSpan(1)[0] = (byte)'}';
+			buffer.Advance(1);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapKeyStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeMapKeyStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			this.WriteIndent(buffer, collectionContext);
 			if (index > 0)
 			{
-				buffer.Write(JsonTokens.Comma);
+				buffer.GetSpan(1)[0] = (byte)',';
+				buffer.Advance(1);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapKeyEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+		public sealed override void EncodeMapKeyEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapValueStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
+		public sealed override void EncodeMapValueStart(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			buffer.Write(JsonTokens.Colon);
-			if (this._isPrettyPrint)
+			if (!this._isPrettyPrint)
 			{
-				buffer.Write(JsonTokens.Whitespace);
+				buffer.GetSpan(1)[0] = (byte)':';
+				buffer.Advance(1);
+			}
+			else
+			{
+				var span = buffer.GetSpan(2);
+				span[0] = (byte)':';
+				span[1] = (byte)' ';
+				buffer.Advance(2);
 			}
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
+		public sealed override void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext) { }
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private static ReadOnlySpan<byte> GetEscapeSequence(byte c, bool newLineAllowed)
+		private static ReadOnlySpan<byte> GetEscapeSequence(byte c, bool newLineAllowed, bool tabAllowed, bool escapeHtmlChars)
 		{
 			switch (c)
 			{
@@ -318,6 +345,11 @@ private static ReadOnlySpan<byte> GetEscapeSequence(byte c, bool newLineAllowed)
 				}
 				case (byte)'"':
 				{
+					if (escapeHtmlChars)
+					{
+						return ReadOnlySpan<byte>.Empty;
+					}
+
 					return JsonEscapeSequence.Quatation;
 				}
 				case (byte)'\\':
@@ -326,6 +358,12 @@ private static ReadOnlySpan<byte> GetEscapeSequence(byte c, bool newLineAllowed)
 				}
 				case (byte)'\t':
 				{
+					if (newLineAllowed)
+					{
+						// Does not escape.
+						return JsonCharactor.Tab;
+					}
+
 					return JsonEscapeSequence.Tab;
 				}
 			}
@@ -335,185 +373,185 @@ private static ReadOnlySpan<byte> GetEscapeSequence(byte c, bool newLineAllowed)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		public sealed override void EncodeString(ReadOnlySpan<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
-			buffer.Write(JsonTokens.Quatation);
-
-			this.EncodeStringBody(encodedValue, 0, buffer);
-
-			// End quot
-			buffer.Write(JsonTokens.Quatation);
-		}
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 
-		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		private void EncodeStringBody(ReadOnlySpan<byte> encodedValue, long position, IBufferWriter<byte> buffer)
-		{
 			var source = encodedValue;
-			while (!source.IsEmpty)
+			this.EncodeStringBody(ref source, 0, buffer, out var requestHint);
+			if (requestHint > 0)
 			{
-				this.EscapeUtf8(ref source, ref position, buffer);
+				JsonThrow.TooShortUtf8();
 			}
+
+			// End quot
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 		}
 
-		private void EscapeUtf8(ref ReadOnlySpan<byte> utf8, ref long position, IBufferWriter<byte> buffer)
+		private void EncodeStringBody(ref ReadOnlySpan<byte> encodedValue, long position, IBufferWriter<byte> buffer, out int requestHint)
 		{
-			if (utf8.IsEmpty)
+			var utf8 = encodedValue;
+			while (utf8.Length > 0)
 			{
-				return;
-			}
-
-			if ((utf8[0] & 0b_1000_0000) == 0)
-			{
-				// 1 byte, 7bits
-				byte codePoint = (byte)(utf8[0] & 0b_0111_1111);
-
-				if (this._escapeTargetChars1Byte.Span.Contains(codePoint)
-					|| codePoint < 0x09 // Control chars must be escaped except horizontal tab
-					|| (this._options.EscapesHorizontalTab && codePoint == 0x09)
-					|| (codePoint > 0x09 && codePoint < 0x20) // Control chars must be escaped except horizontal tab
-					|| codePoint >= 0x7F  // Control chars must be escaped (DEL)
-					)
+				if ((utf8[0] & 0b_1000_0000) == 0)
 				{
-					var escapeSequence = GetEscapeSequence(codePoint, newLineAllowed: false);
-					if (escapeSequence.IsEmpty)
+					// 1 byte, 7bits
+					byte codePoint = utf8[0];
+
+					if (this._escapeTargetChars1Byte.Span.Contains(codePoint)
+						|| codePoint < 0x20 // Control chars must be escaped
+						|| codePoint == 0x7F  // Control chars must be escaped (DEL)
+						)
 					{
-						EscapeCodePoint(codePoint, buffer);
+						var escapeSequence = GetEscapeSequence(codePoint, newLineAllowed: false, tabAllowed: !this._options.EscapesHorizontalTab, this._options.EscapesHtmlChars);
+						if (escapeSequence.IsEmpty)
+						{
+							EscapeCodePoint(codePoint, buffer);
+						}
+						else
+						{
+							buffer.Write(escapeSequence);
+						}
 					}
 					else
 					{
-						buffer.Write(escapeSequence);
+						buffer.Write(utf8.Slice(0, 1));
 					}
-				}
-				else
-				{
-					buffer.Write(utf8.Slice(0, 1));
+
+					utf8 = utf8.Slice(1);
+					position += 1;
 				}
 
-				utf8 = utf8.Slice(1);
-				position += 1;
-			}
-			else if ((utf8[0] & 0b_1110_0000) == 0b_1100_0000)
-			{
-				if (utf8.Length < 2)
+				else if ((utf8[0] & 0b_1110_0000) == 0b_1100_0000)
 				{
-					JsonThrow.TooShortUtf8();
-				}
+					if (utf8.Length < 2)
+					{
+						requestHint = 1;
+						return;
+					}
 
-				// 2 bytes, 5 + 6 bits
-				var bits1 = utf8[0] & 0b_0001_1111;
-				var bits2 = utf8[1] & 0b_0011_1111;
+					// 2 bytes, 5 + 6 bits
+					var bits1 = utf8[0] & 0b_0001_1111;
+					var bits2 = utf8[1] & 0b_0011_1111;
 
-				if ((bits1 & 0b_1_1110) == 0
-					|| (utf8[1] & 0b_1100_0000) != 0b_1000_0000)
-				{
-					JsonThrow.MalformedUtf8(utf8, position);
-				}
+					if ((bits1 & 0b_1_1110) == 0
+						|| (utf8[1] & 0b_1100_0000) != 0b_1000_0000)
+					{
+						JsonThrow.MalformedUtf8(utf8, position);
+					}
 
-				ushort codePoint = (ushort)((bits1 << 6) | (bits2 << 6));
+					ushort codePoint = (ushort)((bits1 << 6) | (bits2 << 6));
 
-				if (codePoint < 0xA0 // Control chars must be escaped
-					|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
-				{
-					EscapeCodePoint(codePoint, buffer);
+					if (codePoint < 0xA0 // Control chars must be escaped
+						|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
+					{
+						EscapeCodePoint(codePoint, buffer);
+					}
+					else
+					{
+						buffer.Write(utf8.Slice(0, 1));
+					}
+
+					utf8 = utf8.Slice(2);
+					position += 2;
 				}
-				else
+				else if ((utf8[0] & 0b_1111_0000) == 0b_1110_0000)
 				{
-					buffer.Write(utf8.Slice(0, 1));
-				}
+					if (utf8.Length < 3)
+					{
+						requestHint = 3 - utf8.Length;
+						return;
+					}
 
-				utf8 = utf8.Slice(2);
-				position += 2;
-			}
-			else if ((utf8[0] & 0b_1111_0000) == 0b_1110_0000)
-			{
-				if (utf8.Length < 3)
-				{
-					JsonThrow.TooShortUtf8();
-				}
+					if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
+						|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000)
+					{
+						JsonThrow.MalformedUtf8(utf8, position);
+					}
 
-				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
-					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000)
-				{
-					JsonThrow.MalformedUtf8(utf8, position);
-				}
+					// 3 bytes, 4 + 6 + 6 bits
+					var bits1 = utf8[0] & 0b_0000_1111;
+					var bits2 = utf8[1] & 0b_0011_1111;
+					var bits3 = utf8[2] & 0b_0011_1111;
 
-				// 3 bytes, 4 + 6 + 6 bits
-				var bits1 = utf8[0] & 0b_0000_1111;
-				var bits2 = utf8[1] & 0b_0011_1111;
-				var bits3 = utf8[2] & 0b_0011_1111;
+					ushort codePoint = (ushort)((bits1 << 12) | (bits2 << 6) | bits3);
 
-				ushort codePoint = (ushort)((bits1 << 12) | (bits2 << 6) | bits3);
+					if ((codePoint & 0b_1111_100000_000000) == 0)
+					{
+						JsonThrow.MalformedUtf8(utf8, position);
+					}
 
-				if ((codePoint & 0b_1111_100000_000000) == 0)
-				{
-					JsonThrow.MalformedUtf8(utf8, position);
-				}
+					if (!Rune.IsValid(codePoint))
+					{
+						JsonThrow.SurrogateCharInUtf8(position, codePoint);
+					}
 
-				if (!Rune.IsValid(codePoint))
-				{
-					JsonThrow.SurrogateCharInUtf8(position, codePoint);
-				}
+					if (codePoint >= 0xFFFE // U+FFFE and U+FFFF are Reserved
+						|| (this._options.EscapesPrivateUseCharactors && codePoint >= 0xE000 && codePoint <= 0xF8FF) // Privte Use
+						|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
+					{
+						EscapeCodePoint(codePoint, buffer);
+					}
+					else
+					{
+						buffer.Write(utf8.Slice(0, 1));
+					}
 
-				if (codePoint >= 0xFFFE // U+FFFE and U+FFFF are Reserved
-					|| (this._options.EscapesPrivateUseCharactors && codePoint >= 0xE000 && codePoint <= 0xF8FF) // Privte Use
-					|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
-				{
-					EscapeCodePoint(codePoint, buffer);
+					utf8 = utf8.Slice(3);
+					position += 3;
 				}
-				else
+				else if ((utf8[0] & 0b_1111_1000) == 0b_1111_0000)
 				{
-					buffer.Write(utf8.Slice(0, 1));
-				}
+					if (utf8.Length < 4)
+					{
+						requestHint = 4 - utf8.Length;
+						return;
+					}
 
-				utf8 = utf8.Slice(3);
-				position += 3;
-			}
-			else if ((utf8[0] & 0b_1111_1000) == 0b_1111_0000)
-			{
-				if (utf8.Length < 4)
-				{
-					JsonThrow.TooShortUtf8();
-				}
+					if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
+						|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000
+						|| (utf8[3] & 0b_1100_0000) != 0b_1000_0000)
+					{
+						JsonThrow.MalformedUtf8(utf8, position);
+					}
 
-				if ((utf8[1] & 0b_1100_0000) != 0b_1000_0000
-					|| (utf8[2] & 0b_1100_0000) != 0b_1000_0000
-					|| (utf8[3] & 0b_1100_0000) != 0b_1000_0000)
-				{
-					JsonThrow.MalformedUtf8(utf8, position);
-				}
+					// 4 bytes, 3 + 6 + 6 + 6 bits
+					var bits1 = (utf8[0] & 0b_0000_0111) << 18;
+					var bits2 = (utf8[1] & 0b_0011_1111) << 12;
+					var bits3 = (utf8[2] & 0b_0011_1111) << 6;
+					var bits4 = (utf8[3] & 0b_0011_1111);
 
-				// 4 bytes, 3 + 6 + 6 + 6 bits
-				var bits1 = (utf8[0] & 0b_0000_0111) << 18;
-				var bits2 = (utf8[1] & 0b_0011_1111) << 12;
-				var bits3 = (utf8[2] & 0b_0011_1111) << 6;
-				var bits4 = (utf8[3] & 0b_0011_1111);
+					int codePoint = ((bits1 << 18) | (bits2 << 12) | (bits3 << 6) | bits4);
 
-				int codePoint = ((bits1 << 18) | (bits2 << 12) | (bits1 << 6) | bits4);
+					if ((codePoint & 0b_111_110000_000000_000000) == 0)
+					{
+						JsonThrow.MalformedUtf8(utf8, position);
+					}
 
-				if ((codePoint & 0b_111_110000_000000_000000) == 0)
-				{
-					JsonThrow.MalformedUtf8(utf8, position);
-				}
+					if ((this._options.EscapesPrivateUseCharactors && codePoint >= 0xF0000) // Private use
+						|| this._escapeTargetChars4Byte.Span.Contains(codePoint))
+					{
+						EscapeCodePoint(codePoint, buffer);
+					}
+					else
+					{
+						buffer.Write(utf8.Slice(0, 1));
+					}
 
-				if ((this._options.EscapesPrivateUseCharactors && codePoint >= 0xF0000) // Private use
-					|| this._escapeTargetChars4Byte.Span.Contains(codePoint))
-				{
-					EscapeCodePoint(codePoint, buffer);
+					utf8 = utf8.Slice(4);
+					position += 4;
 				}
 				else
 				{
-					buffer.Write(utf8.Slice(0, 1));
+					JsonThrow.MalformedUtf8(utf8, position);
 				}
-
-				utf8 = utf8.Slice(4);
-				position += 4;
-			}
-			else
-			{
-				JsonThrow.MalformedUtf8(utf8, position);
 			}
+
+			requestHint = 0;
 		}
 
 		private static void EscapeCodePoint(int codePoint, IBufferWriter<byte> buffer)
@@ -524,130 +562,208 @@ private static void EscapeCodePoint(int codePoint, IBufferWriter<byte> buffer)
 			buffer.Write(numbers);
 		}
 
-		public override void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		public sealed override void EncodeString(in ReadOnlySequence<byte> encodedValue, int charLength, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
+			buffer = Ensure.NotNull(buffer);
 
 			// Start quot
-			buffer.Write(JsonTokens.Quatation);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 
 			var source = new SequenceReader<byte>(encodedValue);
 
-			while (!source.UnreadSpan.IsEmpty)
+			while (!source.End)
 			{
 				var length = source.UnreadSpan.Length;
-				this.EncodeStringBody(source.UnreadSpan, source.Consumed, buffer);
-				source.Advance(length);
+				var span = source.UnreadSpan;
+				this.EncodeStringBody(ref span, source.Consumed, buffer, out var requestHint);
+				source.Advance(length - span.Length);
+
+				if (requestHint > 0)
+				{
+					Span<byte> codePoints = stackalloc byte[span.Length + requestHint];
+					if (!source.TryCopyTo(codePoints))
+					{
+						JsonThrow.TooShortUtf8();
+					}
+
+					source.Advance(codePoints.Length);
+
+					ReadOnlySpan<byte> readOnlyCodePoints = codePoints;
+					this.EncodeStringBody(ref readOnlyCodePoints, source.Consumed, buffer, out requestHint);
+				}
 			}
 
 			// End quot
-			buffer.Write(JsonTokens.Quatation);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 		}
 
-		public override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		public sealed override void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
 		{
-			buffer = EnsureNotNull(buffer);
-			encoding = encoding ?? Utf8EncodingNonBom.Instance;
+			buffer = Ensure.NotNull(buffer);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
+
+			var source = value;
+			this.EncodeStringBody(ref source, buffer, out var requestHint);
+			if (requestHint > 0)
+			{
+				JsonThrow.OrphanSurrogate(value.Length - source.Length, source[0]);
+			}
+
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
+		}
 
-			if (value.Length < 256)
+		public sealed override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			if (value.IsSingleSegment)
 			{
-				// Fast-path with stackalloc
-				var charLength = unchecked((int)value.Length);
-				Span<byte> encodingBuffer = stackalloc byte[encoding.GetMaxByteCount(charLength)];
-				var actualLength = encoding.GetBytes(value, encodingBuffer);
-				this.EncodeString(encodingBuffer.Slice(0, actualLength), charLength, buffer);
+				this.EncodeString(value.FirstSpan, buffer, encoding);
+				return;
 			}
 			else
 			{
-				// Slow-path
+				buffer = Ensure.NotNull(buffer);
 
 				// Start quot
-				buffer.Write(JsonTokens.Quatation);
+				buffer.GetSpan(1)[0] = (byte)'"';
+				buffer.Advance(1);
 
-				var encoder = encoding.GetEncoder();
-				var source = value;
+				var source = new SequenceReader<char>(value);
 
-				var encodingBuffer = base.Options.ByteBufferPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
-				try
+				while (!source.End)
 				{
-					Span<byte> encodingSpan = encodingBuffer;
-					while (!source.IsEmpty)
+					var length = source.UnreadSpan.Length;
+					var span = source.UnreadSpan;
+					this.EncodeStringBody(ref span, buffer, out var requestHint);
+					source.Advance(length - span.Length);
+
+					if (requestHint > 0)
 					{
-						var length = source.Length;
-						encoder.Convert(source, encodingSpan, flush: source.Length <= encodingSpan.Length, out var charsUsed, out var bytesUsed, out _);
+						Span<char> codePoints = stackalloc char[span.Length + requestHint];
+						if (!source.TryCopyTo(codePoints))
+						{
+							JsonThrow.TooShortUtf8();
+						}
 
-						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), position: 0 /* should not be used because ALWAYS valid UTF-8 */, buffer);
-						source = source.Slice(charsUsed);
+						source.Advance(codePoints.Length);
+
+						ReadOnlySpan<char> readOnlyCodePoints = codePoints;
+						this.EncodeStringBody(ref readOnlyCodePoints, buffer, out requestHint);
 					}
 				}
-				finally
-				{
-					base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
-				}
 
 				// End quot
-				buffer.Write(JsonTokens.Quatation);
+				buffer.GetSpan(1)[0] = (byte)'"';
+				buffer.Advance(1);
 			}
 		}
 
-		public override void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		private void EncodeStringBody(ref ReadOnlySpan<char> chars, IBufferWriter<byte> buffer, out int requestHint)
 		{
-			buffer = EnsureNotNull(buffer);
-			encoding = encoding ?? Utf8EncodingNonBom.Instance;
-
-			if (value.IsSingleSegment)
+			var position = 0;
+			for(var i = 0; i < chars.Length; i++)
 			{
-				this.EncodeString(value.FirstSpan, buffer, encoding);
-				return;
-			}
-
-			if (value.Length < 256)
-			{
-				// Fast-path with stackalloc
-				var charLength = unchecked((int)value.Length);
-				Span<byte> encodingBuffer = stackalloc byte[encoding.GetMaxByteCount(charLength)];
-				var actualLength = encoding.GetBytes(value, encodingBuffer);
-				this.EncodeString(encodingBuffer.Slice(0, actualLength), charLength, buffer);
-			}
-			else
-			{
-				// Slow-path
+				var c = chars[i];
+				if (c < 0x80)
+				{
+					var codePoint = (byte)c;
 
-				// Start quot
-				buffer.Write(JsonTokens.Quatation);
+					if (this._escapeTargetChars1Byte.Span.Contains(codePoint)
+						|| codePoint < 0x20 // Control chars must be escaped
+						|| codePoint == 0x7F  // Control chars must be escaped (DEL)
+						)
+					{
+						Utf8EncodingNonBom.Instance.GetBytes(chars.Slice(0, i), buffer);
+						chars = chars.Slice(i + 1);
+						position += i + 1;
+						i = 0;
+
+						var escapeSequence = GetEscapeSequence(codePoint, newLineAllowed: false, tabAllowed: !this._options.EscapesHorizontalTab, this._options.EscapesHtmlChars);
+						if (escapeSequence.IsEmpty)
+						{
+							EscapeCodePoint(codePoint, buffer);
+						}
+						else
+						{
+							buffer.Write(escapeSequence);
+						}
+					}
+				}
+				else if (c < 0x800)
+				{
+					ushort codePoint = c;
 
-				var encoder = encoding.GetEncoder();
-				var source = new SequenceReader<char>(value);
+					if (codePoint < 0xA0 // Control chars must be escaped
+						|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
+					{
+						Utf8EncodingNonBom.Instance.GetBytes(chars.Slice(0, i), buffer);
+						chars = chars.Slice(i);
+						position += i + 1;
+						i = 0;
 
-				var encodingBuffer = base.Options.ByteBufferPool.Rent(Math.Min(2 * 1024 * 1024, encoding.GetMaxByteCount(unchecked((int)(value.Length & 0x1FFFFFFF)))));
-				try
+						EscapeCodePoint(codePoint, buffer);
+					}
+				}
+				else if (!Char.IsSurrogate(c))
 				{
-					Span<byte> encodingSpan = encodingBuffer;
-					while (!source.UnreadSpan.IsEmpty)
-					{
-						cancellationToken.ThrowIfCancellationRequested();
+					ushort codePoint = c;
 
-						var length = source.UnreadSpan.Length;
-						encoder.Convert(source.UnreadSpan, encodingSpan, flush: source.Remaining <= encodingSpan.Length, out var charsUsed, out var bytesUsed, out _);
+					if (codePoint >= 0xFFFE // U+FFFE and U+FFFF are Reserved
+						|| (this._options.EscapesPrivateUseCharactors && codePoint >= 0xE000 && codePoint <= 0xF8FF) // Privte Use
+						|| this._escapeTargetChars2Byte.Span.Contains(codePoint))
+					{
+						Utf8EncodingNonBom.Instance.GetBytes(chars.Slice(0, i), buffer);
+						chars = chars.Slice(i);
+						position += i + 1;
+						i = 0;
 
-						this.EncodeStringBody(encodingSpan.Slice(0, bytesUsed), position: 0 /* should not be used because ALWAYS valid UTF-8 */, buffer);
-						source.Advance(charsUsed);
+						EscapeCodePoint(codePoint, buffer);
 					}
 				}
-				finally
+				else
 				{
-					base.Options.ByteBufferPool.Return(encodingBuffer, base.Options.ClearsBuffer);
-				}
+					// Surrogate
+					if(chars.Length < i + 2)
+					{
+						Utf8EncodingNonBom.Instance.GetBytes(chars.Slice(0, i), buffer);
+						chars = chars.Slice(i);
+						position += i;
+						i = 0;
+						requestHint = 1;
+						return;
+					}
 
-				// End quot
-				buffer.Write(JsonTokens.Quatation);
+					if(!Char.IsSurrogatePair(c, chars[1]))
+					{
+						JsonThrow.OrphanSurrogate(position, c);
+					}
+
+					var codePoint = Char.ConvertToUtf32(c, chars[1]);
+
+					if ((this._options.EscapesPrivateUseCharactors && codePoint >= 0xF0000) // Private use
+						|| this._escapeTargetChars4Byte.Span.Contains(codePoint))
+					{
+						EscapeCodePoint(codePoint, buffer);
+					}
+
+					position += 2;
+					i++;
+				}
 			}
+
+			requestHint = 0;
+			Utf8EncodingNonBom.Instance.GetBytes(chars, buffer);
+			chars = ReadOnlySpan<char>.Empty;
 		}
 
-		public override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		public sealed override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
 			// Start quot
-			buffer.Write(JsonTokens.Quatation);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 
 			if (value.Length < this.Options.CancellationSupportThreshold)
 			{
@@ -662,7 +778,8 @@ public override void EncodeBinary(ReadOnlySpan<byte> value, IBufferWriter<byte>
 			}
 
 			// End quot
-			buffer.Write(JsonTokens.Quatation);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 		}
 
 		[MethodImpl(MethodImplOptions.NoInlining)]
@@ -682,7 +799,7 @@ private static void EncodeBinarySlow(ReadOnlySpan<byte> value, IBufferWriter<byt
 			}
 		}
 
-		public override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
+		public sealed override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter<byte> buffer, CancellationToken cancellationToken = default)
 		{
 			if (value.IsSingleSegment)
 			{
@@ -692,7 +809,8 @@ public override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter
 			}
 
 			// Start quot
-			buffer.Write(JsonTokens.Quatation);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 
 			var reader = new SequenceReader<byte>(value);
 			while (true)
@@ -709,7 +827,8 @@ public override void EncodeBinary(in ReadOnlySequence<byte> value, IBufferWriter
 			}
 
 			// End quot
-			buffer.Write(JsonTokens.Quatation);
+			buffer.GetSpan(1)[0] = (byte)'"';
+			buffer.Advance(1);
 		}
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptions.cs b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
index 66014e1cf..0fa00f966 100644
--- a/src/MsgPack.Json/Json/JsonEncoderOptions.cs
+++ b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
@@ -13,19 +13,21 @@ namespace MsgPack.Json
 	/// <summary>
 	///		Defines encoder options for <see cref="JsonEncoder"/>.
 	/// </summary>
-	public class JsonEncoderOptions : EncoderOptions
+	public sealed class JsonEncoderOptions : EncoderOptions
 	{
+		public static JsonEncoderOptions Default { get; } = new JsonEncoderOptionsBuilder().Build();
+
 		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> ErrorSingleInfinityFormatter =
 			(value, buffer, options) => throw new ArgumentException($"Cannot serialize infinity ({value}) to JSON.", "value");
 
 		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> MinMaxSingleInfinityFormatter =
-			(value, buffer, options) => JsonFormatter.Format(Single.IsPositiveInfinity(value) ? Single.MaxValue : Single.MinValue, buffer, options);
+			(value, buffer, _) => JsonFormatter.Format(Single.IsPositiveInfinity(value) ? Single.MaxValue : Single.MinValue, buffer);
 
 		private static readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> ErrorDoubleInfinityFormatter =
 			(value, buffer, options) => throw new ArgumentException($"Cannot serialize infinity ({value}) to JSON.", "value");
 
 		private static readonly Action<double, IBufferWriter<byte>, JsonEncoderOptions> MinMaxDoubleInfinityFormatter =
-			(value, buffer, options) => JsonFormatter.Format(Double.IsPositiveInfinity(value) ? Double.MaxValue : Double.MinValue, buffer, options);
+			(value, buffer, _) => JsonFormatter.Format(Double.IsPositiveInfinity(value) ? Double.MaxValue : Double.MinValue, buffer);
 
 		private static readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> ErrorSingleNaNFormatter =
 			(value, buffer, options) => throw new ArgumentException($"Cannot serialize NaN to JSON.", "value");
@@ -47,6 +49,7 @@ public class JsonEncoderOptions : EncoderOptions
 		public ReadOnlyMemory<byte> NewLineChars { get; }
 		public bool IsPrettyPrint { get; }
 		public bool EscapesHorizontalTab { get; }
+		public bool EscapesHtmlChars { get; }
 		public bool EscapesPrivateUseCharactors { get; }
 		public ReadOnlyMemory<Rune> EscapeTargetChars { get; }
 		internal ReadOnlyMemory<byte> EscapeTargetChars1Byte { get; }
@@ -92,11 +95,12 @@ public JsonEncoderOptions(JsonEncoderOptionsBuilder builder)
 			this.IndentChars = builder.IndentChars;
 			this.NewLineChars = builder.NewLineChars;
 			this.IsPrettyPrint = builder.IsPrettyPrint;
-			var escapeTargetChars = builder.AdditionalEscapeTargetChars.ToArray().Concat(JsonCharactor.MustBeEscaped1Byte.Select(b => new Rune(b))).Distinct().OrderBy(r => r).ToArray();
+			var escapeTargetChars = builder.AdditionalEscapeTargetChars.ToArray().Concat(JsonCharactor.MustBeEscaped1Byte.Select(b => new Rune(b))).Concat(builder.EscapesHtmlChars ? JsonCharactor.ShouldBeEscaped.ToArray() : Array.Empty<Rune>()).Distinct().OrderBy(r => r).ToArray();
 			this.EscapeTargetChars = escapeTargetChars;
 			this.EscapeTargetChars1Byte = escapeTargetChars.Where(r => r.Value <= Byte.MaxValue).Select(r => (byte)r.Value).ToArray();
 			this.EscapeTargetChars2Byte = escapeTargetChars.Where(r => r.Value > Byte.MaxValue && r.Value <= UInt16.MaxValue).Select(r => (ushort)r.Value).ToArray();
 			this.EscapeTargetChars4Byte = escapeTargetChars.Where(r => r.Value > UInt16.MaxValue).Select(r => r.Value).ToArray();
+			this.EscapesHtmlChars = builder.EscapesHtmlChars;
 			this.EscapesHorizontalTab = builder.EscapesHorizontalTab;
 			this.EscapesPrivateUseCharactors = builder.EscapesPrivateUseCharactors;
 		}
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs b/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
index c68260e1d..812dc7680 100644
--- a/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
+++ b/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
@@ -103,7 +103,8 @@ public ReadOnlyMemory<byte> NewLineChars
 		public ReadOnlyMemory<Rune> AdditionalEscapeTargetChars { get; set; }
 
 		public bool EscapesHorizontalTab { get; set; } = true;
-		public bool EscapesPrivateUseCharactors { get; set; } = true;
+		public bool EscapesPrivateUseCharactors { get; set; } = false;
+		public bool EscapesHtmlChars { get; set; } = false;
 
 		internal Action<float, IBufferWriter<byte>, JsonEncoderOptions>? SingleInfinityFormatter;
 		internal Action<double, IBufferWriter<byte>, JsonEncoderOptions>? DoubleInfinityFormatter;
@@ -136,7 +137,7 @@ Action<double, IBufferWriter<byte>, JsonEncoderOptions> doubleNaNFormatter
 
 		public JsonEncoderOptionsBuilder WithHtmlCharactorEscaping()
 		{
-			this.AdditionalEscapeTargetChars = JsonCharactor.ShouldBeEscaped;
+			this.EscapesHtmlChars = true;
 			return this;
 		}
 
diff --git a/src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.cs b/src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.cs
new file mode 100644
index 000000000..bd248b274
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.cs
@@ -0,0 +1,2186 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace MsgPack.Json
+{
+	partial class JsonEscapeSequence
+	{
+
+		public static ReadOnlySpan<ulong> BaseEscapeTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, ulong>(BaseEscapeTableLittleEndian) :
+				MemoryMarshal.Cast<byte, ulong>(BaseEscapeTableBigEndian);
+
+		public static ReadOnlySpan<int> BaseEscapeLengthTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, int>(BaseEscapeLengthTableLittleEndian) :
+				MemoryMarshal.Cast<byte, int>(BaseEscapeLengthTableBigEndian);
+
+		public static ReadOnlySpan<byte> BaseEscapeTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000000000,
+				0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000010000,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000020000,
+				0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000030000,
+				0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000040000,
+				0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000050000,
+				0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000060000,
+				0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000070000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x5C, // 0x5C62000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x5C, // 0x5C74000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x5C, // 0x5C6E000000000000,
+				0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000B0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x5C, // 0x5C66000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x5C, // 0x5C72000000000000,
+				0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000E0000,
+				0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000F0000,
+				0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000100000,
+				0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000110000,
+				0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000120000,
+				0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000130000,
+				0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000140000,
+				0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000150000,
+				0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000160000,
+				0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000170000,
+				0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000180000,
+				0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000190000,
+				0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001A0000,
+				0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001B0000,
+				0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001C0000,
+				0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001D0000,
+				0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001E0000,
+				0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001F0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, // 0x2000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, // 0x2100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x5C, // 0x5C22000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, // 0x2300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, // 0x2400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, // 0x2500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, // 0x2600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, // 0x2700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, // 0x2800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, // 0x2900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2A, // 0x2A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, // 0x2B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, // 0x2C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2D, // 0x2D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, // 0x2E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, // 0x2F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, // 0x3000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, // 0x3100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, // 0x3200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, // 0x3300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, // 0x3400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, // 0x3500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, // 0x3600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, // 0x3700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, // 0x3800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, // 0x3900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3A, // 0x3A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, // 0x3B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, // 0x3C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, // 0x3D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, // 0x3E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, // 0x3F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, // 0x4000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, // 0x4100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, // 0x4200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, // 0x4300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, // 0x4400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, // 0x4500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, // 0x4600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, // 0x4700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, // 0x4800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, // 0x4900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, // 0x4A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4B, // 0x4B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, // 0x4C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, // 0x4D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, // 0x4E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, // 0x4F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, // 0x5000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, // 0x5100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, // 0x5200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, // 0x5300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, // 0x5400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, // 0x5500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, // 0x5600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, // 0x5700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, // 0x5800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, // 0x5900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, // 0x5A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5B, // 0x5B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0x5C, // 0x5C5C000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, // 0x5D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5E, // 0x5E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, // 0x5F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, // 0x6000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, // 0x6100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, // 0x6200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, // 0x6300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, // 0x6400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, // 0x6500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, // 0x6600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, // 0x6700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, // 0x6800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, // 0x6900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6A, // 0x6A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6B, // 0x6B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, // 0x6C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6D, // 0x6D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, // 0x6E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6F, // 0x6F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, // 0x7000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, // 0x7100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, // 0x7200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, // 0x7300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, // 0x7400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, // 0x7500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, // 0x7600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, // 0x7700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, // 0x7800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79, // 0x7900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, // 0x7A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, // 0x7B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, // 0x7C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7D, // 0x7D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, // 0x7E00000000000000,
+				0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000007F0000,
+			};
+
+		public static ReadOnlySpan<byte> BaseEscapeTableLittleEndian =>
+			new byte[]
+			{
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // 0x000001000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, // 0x000002000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // 0x000003000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, // 0x000004000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, // 0x000005000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, // 0x000006000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, // 0x000007000000755C,
+				0x5C, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000625C,
+				0x5C, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000745C,
+				0x5C, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000006E5C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, // 0x00000B000000755C,
+				0x5C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000665C,
+				0x5C, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000725C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, // 0x00000E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, // 0x00000F000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, // 0x000010000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, // 0x000011000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, // 0x000012000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, // 0x000013000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, // 0x000014000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, // 0x000015000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, // 0x000016000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, // 0x000017000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, // 0x000018000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, // 0x000019000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, // 0x00001A000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, // 0x00001B000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, // 0x00001C000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, // 0x00001D000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, // 0x00001E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, // 0x00001F000000755C,
+				0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000020,
+				0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000021,
+				0x5C, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000225C,
+				0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000023,
+				0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000024,
+				0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000025,
+				0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000026,
+				0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000027,
+				0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000028,
+				0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000029,
+				0x2A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002A,
+				0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002B,
+				0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002C,
+				0x2D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002D,
+				0x2E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002E,
+				0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002F,
+				0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000030,
+				0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000031,
+				0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000032,
+				0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000033,
+				0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000034,
+				0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000035,
+				0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000036,
+				0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000037,
+				0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000038,
+				0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000039,
+				0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003A,
+				0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003B,
+				0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003C,
+				0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003D,
+				0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003E,
+				0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003F,
+				0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000040,
+				0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000041,
+				0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000042,
+				0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000043,
+				0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000044,
+				0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000045,
+				0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000046,
+				0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000047,
+				0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000048,
+				0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000049,
+				0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004A,
+				0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004B,
+				0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004C,
+				0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004D,
+				0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004E,
+				0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004F,
+				0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000050,
+				0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000051,
+				0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000052,
+				0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000053,
+				0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000054,
+				0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000055,
+				0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000056,
+				0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000057,
+				0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000058,
+				0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000059,
+				0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005A,
+				0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005B,
+				0x5C, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000005C5C,
+				0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005D,
+				0x5E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005E,
+				0x5F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005F,
+				0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000060,
+				0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000061,
+				0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000062,
+				0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000063,
+				0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000064,
+				0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000065,
+				0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000066,
+				0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000067,
+				0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000068,
+				0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000069,
+				0x6A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006A,
+				0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006B,
+				0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006C,
+				0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006D,
+				0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006E,
+				0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006F,
+				0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000070,
+				0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000071,
+				0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000072,
+				0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000073,
+				0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000074,
+				0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000075,
+				0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000076,
+				0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000077,
+				0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000078,
+				0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000079,
+				0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007A,
+				0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007B,
+				0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007C,
+				0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007D,
+				0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007E,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, // 0x00007F000000755C,
+			};
+
+		public static ReadOnlySpan<byte> BaseEscapeLengthTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-00),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-01),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-02),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-03),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-04),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-05),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-06),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-07),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-62),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-74),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-6E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-66),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-72),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0F),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-10),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-11),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-12),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-13),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-14),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-15),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-16),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-17),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-18),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-19),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1A),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1B),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1C),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1D),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1F),
+				0x00, 0x00, 0x00, 0x01, // 1 (20),
+				0x00, 0x00, 0x00, 0x01, // 1 (21),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-22),
+				0x00, 0x00, 0x00, 0x01, // 1 (23),
+				0x00, 0x00, 0x00, 0x01, // 1 (24),
+				0x00, 0x00, 0x00, 0x01, // 1 (25),
+				0x00, 0x00, 0x00, 0x01, // 1 (26),
+				0x00, 0x00, 0x00, 0x01, // 1 (27),
+				0x00, 0x00, 0x00, 0x01, // 1 (28),
+				0x00, 0x00, 0x00, 0x01, // 1 (29),
+				0x00, 0x00, 0x00, 0x01, // 1 (2A),
+				0x00, 0x00, 0x00, 0x01, // 1 (2B),
+				0x00, 0x00, 0x00, 0x01, // 1 (2C),
+				0x00, 0x00, 0x00, 0x01, // 1 (2D),
+				0x00, 0x00, 0x00, 0x01, // 1 (2E),
+				0x00, 0x00, 0x00, 0x01, // 1 (2F),
+				0x00, 0x00, 0x00, 0x01, // 1 (30),
+				0x00, 0x00, 0x00, 0x01, // 1 (31),
+				0x00, 0x00, 0x00, 0x01, // 1 (32),
+				0x00, 0x00, 0x00, 0x01, // 1 (33),
+				0x00, 0x00, 0x00, 0x01, // 1 (34),
+				0x00, 0x00, 0x00, 0x01, // 1 (35),
+				0x00, 0x00, 0x00, 0x01, // 1 (36),
+				0x00, 0x00, 0x00, 0x01, // 1 (37),
+				0x00, 0x00, 0x00, 0x01, // 1 (38),
+				0x00, 0x00, 0x00, 0x01, // 1 (39),
+				0x00, 0x00, 0x00, 0x01, // 1 (3A),
+				0x00, 0x00, 0x00, 0x01, // 1 (3B),
+				0x00, 0x00, 0x00, 0x01, // 1 (3C),
+				0x00, 0x00, 0x00, 0x01, // 1 (3D),
+				0x00, 0x00, 0x00, 0x01, // 1 (3E),
+				0x00, 0x00, 0x00, 0x01, // 1 (3F),
+				0x00, 0x00, 0x00, 0x01, // 1 (40),
+				0x00, 0x00, 0x00, 0x01, // 1 (41),
+				0x00, 0x00, 0x00, 0x01, // 1 (42),
+				0x00, 0x00, 0x00, 0x01, // 1 (43),
+				0x00, 0x00, 0x00, 0x01, // 1 (44),
+				0x00, 0x00, 0x00, 0x01, // 1 (45),
+				0x00, 0x00, 0x00, 0x01, // 1 (46),
+				0x00, 0x00, 0x00, 0x01, // 1 (47),
+				0x00, 0x00, 0x00, 0x01, // 1 (48),
+				0x00, 0x00, 0x00, 0x01, // 1 (49),
+				0x00, 0x00, 0x00, 0x01, // 1 (4A),
+				0x00, 0x00, 0x00, 0x01, // 1 (4B),
+				0x00, 0x00, 0x00, 0x01, // 1 (4C),
+				0x00, 0x00, 0x00, 0x01, // 1 (4D),
+				0x00, 0x00, 0x00, 0x01, // 1 (4E),
+				0x00, 0x00, 0x00, 0x01, // 1 (4F),
+				0x00, 0x00, 0x00, 0x01, // 1 (50),
+				0x00, 0x00, 0x00, 0x01, // 1 (51),
+				0x00, 0x00, 0x00, 0x01, // 1 (52),
+				0x00, 0x00, 0x00, 0x01, // 1 (53),
+				0x00, 0x00, 0x00, 0x01, // 1 (54),
+				0x00, 0x00, 0x00, 0x01, // 1 (55),
+				0x00, 0x00, 0x00, 0x01, // 1 (56),
+				0x00, 0x00, 0x00, 0x01, // 1 (57),
+				0x00, 0x00, 0x00, 0x01, // 1 (58),
+				0x00, 0x00, 0x00, 0x01, // 1 (59),
+				0x00, 0x00, 0x00, 0x01, // 1 (5A),
+				0x00, 0x00, 0x00, 0x01, // 1 (5B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-5C),
+				0x00, 0x00, 0x00, 0x01, // 1 (5D),
+				0x00, 0x00, 0x00, 0x01, // 1 (5E),
+				0x00, 0x00, 0x00, 0x01, // 1 (5F),
+				0x00, 0x00, 0x00, 0x01, // 1 (60),
+				0x00, 0x00, 0x00, 0x01, // 1 (61),
+				0x00, 0x00, 0x00, 0x01, // 1 (62),
+				0x00, 0x00, 0x00, 0x01, // 1 (63),
+				0x00, 0x00, 0x00, 0x01, // 1 (64),
+				0x00, 0x00, 0x00, 0x01, // 1 (65),
+				0x00, 0x00, 0x00, 0x01, // 1 (66),
+				0x00, 0x00, 0x00, 0x01, // 1 (67),
+				0x00, 0x00, 0x00, 0x01, // 1 (68),
+				0x00, 0x00, 0x00, 0x01, // 1 (69),
+				0x00, 0x00, 0x00, 0x01, // 1 (6A),
+				0x00, 0x00, 0x00, 0x01, // 1 (6B),
+				0x00, 0x00, 0x00, 0x01, // 1 (6C),
+				0x00, 0x00, 0x00, 0x01, // 1 (6D),
+				0x00, 0x00, 0x00, 0x01, // 1 (6E),
+				0x00, 0x00, 0x00, 0x01, // 1 (6F),
+				0x00, 0x00, 0x00, 0x01, // 1 (70),
+				0x00, 0x00, 0x00, 0x01, // 1 (71),
+				0x00, 0x00, 0x00, 0x01, // 1 (72),
+				0x00, 0x00, 0x00, 0x01, // 1 (73),
+				0x00, 0x00, 0x00, 0x01, // 1 (74),
+				0x00, 0x00, 0x00, 0x01, // 1 (75),
+				0x00, 0x00, 0x00, 0x01, // 1 (76),
+				0x00, 0x00, 0x00, 0x01, // 1 (77),
+				0x00, 0x00, 0x00, 0x01, // 1 (78),
+				0x00, 0x00, 0x00, 0x01, // 1 (79),
+				0x00, 0x00, 0x00, 0x01, // 1 (7A),
+				0x00, 0x00, 0x00, 0x01, // 1 (7B),
+				0x00, 0x00, 0x00, 0x01, // 1 (7C),
+				0x00, 0x00, 0x00, 0x01, // 1 (7D),
+				0x00, 0x00, 0x00, 0x01, // 1 (7E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<byte> BaseEscapeLengthTableLittleEndian =>
+			new byte[]
+			{
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-00),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-01),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-02),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-03),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-04),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-05),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-06),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-07),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-62),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-74),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-6E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-66),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-72),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0F),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-10),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-11),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-12),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-13),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-14),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-15),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-16),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-17),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-18),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-19),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1A),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1B),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1C),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1D),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1F),
+				0x01, 0x00, 0x00, 0x00, // 1 (20),
+				0x01, 0x00, 0x00, 0x00, // 1 (21),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-22),
+				0x01, 0x00, 0x00, 0x00, // 1 (23),
+				0x01, 0x00, 0x00, 0x00, // 1 (24),
+				0x01, 0x00, 0x00, 0x00, // 1 (25),
+				0x01, 0x00, 0x00, 0x00, // 1 (26),
+				0x01, 0x00, 0x00, 0x00, // 1 (27),
+				0x01, 0x00, 0x00, 0x00, // 1 (28),
+				0x01, 0x00, 0x00, 0x00, // 1 (29),
+				0x01, 0x00, 0x00, 0x00, // 1 (2A),
+				0x01, 0x00, 0x00, 0x00, // 1 (2B),
+				0x01, 0x00, 0x00, 0x00, // 1 (2C),
+				0x01, 0x00, 0x00, 0x00, // 1 (2D),
+				0x01, 0x00, 0x00, 0x00, // 1 (2E),
+				0x01, 0x00, 0x00, 0x00, // 1 (2F),
+				0x01, 0x00, 0x00, 0x00, // 1 (30),
+				0x01, 0x00, 0x00, 0x00, // 1 (31),
+				0x01, 0x00, 0x00, 0x00, // 1 (32),
+				0x01, 0x00, 0x00, 0x00, // 1 (33),
+				0x01, 0x00, 0x00, 0x00, // 1 (34),
+				0x01, 0x00, 0x00, 0x00, // 1 (35),
+				0x01, 0x00, 0x00, 0x00, // 1 (36),
+				0x01, 0x00, 0x00, 0x00, // 1 (37),
+				0x01, 0x00, 0x00, 0x00, // 1 (38),
+				0x01, 0x00, 0x00, 0x00, // 1 (39),
+				0x01, 0x00, 0x00, 0x00, // 1 (3A),
+				0x01, 0x00, 0x00, 0x00, // 1 (3B),
+				0x01, 0x00, 0x00, 0x00, // 1 (3C),
+				0x01, 0x00, 0x00, 0x00, // 1 (3D),
+				0x01, 0x00, 0x00, 0x00, // 1 (3E),
+				0x01, 0x00, 0x00, 0x00, // 1 (3F),
+				0x01, 0x00, 0x00, 0x00, // 1 (40),
+				0x01, 0x00, 0x00, 0x00, // 1 (41),
+				0x01, 0x00, 0x00, 0x00, // 1 (42),
+				0x01, 0x00, 0x00, 0x00, // 1 (43),
+				0x01, 0x00, 0x00, 0x00, // 1 (44),
+				0x01, 0x00, 0x00, 0x00, // 1 (45),
+				0x01, 0x00, 0x00, 0x00, // 1 (46),
+				0x01, 0x00, 0x00, 0x00, // 1 (47),
+				0x01, 0x00, 0x00, 0x00, // 1 (48),
+				0x01, 0x00, 0x00, 0x00, // 1 (49),
+				0x01, 0x00, 0x00, 0x00, // 1 (4A),
+				0x01, 0x00, 0x00, 0x00, // 1 (4B),
+				0x01, 0x00, 0x00, 0x00, // 1 (4C),
+				0x01, 0x00, 0x00, 0x00, // 1 (4D),
+				0x01, 0x00, 0x00, 0x00, // 1 (4E),
+				0x01, 0x00, 0x00, 0x00, // 1 (4F),
+				0x01, 0x00, 0x00, 0x00, // 1 (50),
+				0x01, 0x00, 0x00, 0x00, // 1 (51),
+				0x01, 0x00, 0x00, 0x00, // 1 (52),
+				0x01, 0x00, 0x00, 0x00, // 1 (53),
+				0x01, 0x00, 0x00, 0x00, // 1 (54),
+				0x01, 0x00, 0x00, 0x00, // 1 (55),
+				0x01, 0x00, 0x00, 0x00, // 1 (56),
+				0x01, 0x00, 0x00, 0x00, // 1 (57),
+				0x01, 0x00, 0x00, 0x00, // 1 (58),
+				0x01, 0x00, 0x00, 0x00, // 1 (59),
+				0x01, 0x00, 0x00, 0x00, // 1 (5A),
+				0x01, 0x00, 0x00, 0x00, // 1 (5B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-5C),
+				0x01, 0x00, 0x00, 0x00, // 1 (5D),
+				0x01, 0x00, 0x00, 0x00, // 1 (5E),
+				0x01, 0x00, 0x00, 0x00, // 1 (5F),
+				0x01, 0x00, 0x00, 0x00, // 1 (60),
+				0x01, 0x00, 0x00, 0x00, // 1 (61),
+				0x01, 0x00, 0x00, 0x00, // 1 (62),
+				0x01, 0x00, 0x00, 0x00, // 1 (63),
+				0x01, 0x00, 0x00, 0x00, // 1 (64),
+				0x01, 0x00, 0x00, 0x00, // 1 (65),
+				0x01, 0x00, 0x00, 0x00, // 1 (66),
+				0x01, 0x00, 0x00, 0x00, // 1 (67),
+				0x01, 0x00, 0x00, 0x00, // 1 (68),
+				0x01, 0x00, 0x00, 0x00, // 1 (69),
+				0x01, 0x00, 0x00, 0x00, // 1 (6A),
+				0x01, 0x00, 0x00, 0x00, // 1 (6B),
+				0x01, 0x00, 0x00, 0x00, // 1 (6C),
+				0x01, 0x00, 0x00, 0x00, // 1 (6D),
+				0x01, 0x00, 0x00, 0x00, // 1 (6E),
+				0x01, 0x00, 0x00, 0x00, // 1 (6F),
+				0x01, 0x00, 0x00, 0x00, // 1 (70),
+				0x01, 0x00, 0x00, 0x00, // 1 (71),
+				0x01, 0x00, 0x00, 0x00, // 1 (72),
+				0x01, 0x00, 0x00, 0x00, // 1 (73),
+				0x01, 0x00, 0x00, 0x00, // 1 (74),
+				0x01, 0x00, 0x00, 0x00, // 1 (75),
+				0x01, 0x00, 0x00, 0x00, // 1 (76),
+				0x01, 0x00, 0x00, 0x00, // 1 (77),
+				0x01, 0x00, 0x00, 0x00, // 1 (78),
+				0x01, 0x00, 0x00, 0x00, // 1 (79),
+				0x01, 0x00, 0x00, 0x00, // 1 (7A),
+				0x01, 0x00, 0x00, 0x00, // 1 (7B),
+				0x01, 0x00, 0x00, 0x00, // 1 (7C),
+				0x01, 0x00, 0x00, 0x00, // 1 (7D),
+				0x01, 0x00, 0x00, 0x00, // 1 (7E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<ulong> BaseWithoutTabEscapeTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, ulong>(BaseWithoutTabEscapeTableLittleEndian) :
+				MemoryMarshal.Cast<byte, ulong>(BaseWithoutTabEscapeTableBigEndian);
+
+		public static ReadOnlySpan<int> BaseWithoutTabEscapeLengthTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, int>(BaseWithoutTabEscapeLengthTableLittleEndian) :
+				MemoryMarshal.Cast<byte, int>(BaseWithoutTabEscapeLengthTableBigEndian);
+
+		public static ReadOnlySpan<byte> BaseWithoutTabEscapeTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000000000,
+				0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000010000,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000020000,
+				0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000030000,
+				0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000040000,
+				0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000050000,
+				0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000060000,
+				0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000070000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x5C, // 0x5C62000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, // 0x0900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x5C, // 0x5C6E000000000000,
+				0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000B0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x5C, // 0x5C66000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x5C, // 0x5C72000000000000,
+				0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000E0000,
+				0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000F0000,
+				0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000100000,
+				0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000110000,
+				0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000120000,
+				0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000130000,
+				0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000140000,
+				0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000150000,
+				0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000160000,
+				0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000170000,
+				0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000180000,
+				0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000190000,
+				0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001A0000,
+				0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001B0000,
+				0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001C0000,
+				0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001D0000,
+				0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001E0000,
+				0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001F0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, // 0x2000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, // 0x2100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x5C, // 0x5C22000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, // 0x2300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, // 0x2400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, // 0x2500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, // 0x2600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, // 0x2700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, // 0x2800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, // 0x2900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2A, // 0x2A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, // 0x2B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, // 0x2C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2D, // 0x2D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, // 0x2E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2F, // 0x2F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, // 0x3000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, // 0x3100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, // 0x3200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, // 0x3300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, // 0x3400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, // 0x3500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, // 0x3600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, // 0x3700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, // 0x3800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, // 0x3900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3A, // 0x3A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, // 0x3B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, // 0x3C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, // 0x3D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, // 0x3E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, // 0x3F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, // 0x4000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, // 0x4100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, // 0x4200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, // 0x4300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, // 0x4400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, // 0x4500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, // 0x4600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, // 0x4700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, // 0x4800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, // 0x4900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, // 0x4A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4B, // 0x4B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, // 0x4C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, // 0x4D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, // 0x4E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, // 0x4F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, // 0x5000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, // 0x5100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, // 0x5200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, // 0x5300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, // 0x5400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, // 0x5500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, // 0x5600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, // 0x5700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, // 0x5800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, // 0x5900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, // 0x5A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5B, // 0x5B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0x5C, // 0x5C5C000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, // 0x5D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5E, // 0x5E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, // 0x5F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, // 0x6000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, // 0x6100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, // 0x6200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, // 0x6300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, // 0x6400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, // 0x6500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, // 0x6600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, // 0x6700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, // 0x6800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, // 0x6900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6A, // 0x6A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6B, // 0x6B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, // 0x6C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6D, // 0x6D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, // 0x6E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6F, // 0x6F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, // 0x7000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, // 0x7100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, // 0x7200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, // 0x7300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, // 0x7400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, // 0x7500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, // 0x7600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, // 0x7700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, // 0x7800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79, // 0x7900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, // 0x7A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, // 0x7B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, // 0x7C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7D, // 0x7D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, // 0x7E00000000000000,
+				0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000007F0000,
+			};
+
+		public static ReadOnlySpan<byte> BaseWithoutTabEscapeTableLittleEndian =>
+			new byte[]
+			{
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // 0x000001000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, // 0x000002000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // 0x000003000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, // 0x000004000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, // 0x000005000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, // 0x000006000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, // 0x000007000000755C,
+				0x5C, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000625C,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000009,
+				0x5C, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000006E5C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, // 0x00000B000000755C,
+				0x5C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000665C,
+				0x5C, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000725C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, // 0x00000E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, // 0x00000F000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, // 0x000010000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, // 0x000011000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, // 0x000012000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, // 0x000013000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, // 0x000014000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, // 0x000015000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, // 0x000016000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, // 0x000017000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, // 0x000018000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, // 0x000019000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, // 0x00001A000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, // 0x00001B000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, // 0x00001C000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, // 0x00001D000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, // 0x00001E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, // 0x00001F000000755C,
+				0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000020,
+				0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000021,
+				0x5C, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000225C,
+				0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000023,
+				0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000024,
+				0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000025,
+				0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000026,
+				0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000027,
+				0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000028,
+				0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000029,
+				0x2A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002A,
+				0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002B,
+				0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002C,
+				0x2D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002D,
+				0x2E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002E,
+				0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002F,
+				0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000030,
+				0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000031,
+				0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000032,
+				0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000033,
+				0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000034,
+				0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000035,
+				0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000036,
+				0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000037,
+				0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000038,
+				0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000039,
+				0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003A,
+				0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003B,
+				0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003C,
+				0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003D,
+				0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003E,
+				0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003F,
+				0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000040,
+				0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000041,
+				0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000042,
+				0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000043,
+				0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000044,
+				0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000045,
+				0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000046,
+				0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000047,
+				0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000048,
+				0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000049,
+				0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004A,
+				0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004B,
+				0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004C,
+				0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004D,
+				0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004E,
+				0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004F,
+				0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000050,
+				0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000051,
+				0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000052,
+				0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000053,
+				0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000054,
+				0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000055,
+				0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000056,
+				0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000057,
+				0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000058,
+				0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000059,
+				0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005A,
+				0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005B,
+				0x5C, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000005C5C,
+				0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005D,
+				0x5E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005E,
+				0x5F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005F,
+				0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000060,
+				0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000061,
+				0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000062,
+				0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000063,
+				0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000064,
+				0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000065,
+				0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000066,
+				0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000067,
+				0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000068,
+				0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000069,
+				0x6A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006A,
+				0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006B,
+				0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006C,
+				0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006D,
+				0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006E,
+				0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006F,
+				0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000070,
+				0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000071,
+				0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000072,
+				0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000073,
+				0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000074,
+				0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000075,
+				0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000076,
+				0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000077,
+				0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000078,
+				0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000079,
+				0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007A,
+				0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007B,
+				0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007C,
+				0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007D,
+				0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007E,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, // 0x00007F000000755C,
+			};
+
+		public static ReadOnlySpan<byte> BaseWithoutTabEscapeLengthTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-00),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-01),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-02),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-03),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-04),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-05),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-06),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-07),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-62),
+				0x00, 0x00, 0x00, 0x01, // 1 (09),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-6E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-66),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-72),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0F),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-10),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-11),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-12),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-13),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-14),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-15),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-16),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-17),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-18),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-19),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1A),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1B),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1C),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1D),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1F),
+				0x00, 0x00, 0x00, 0x01, // 1 (20),
+				0x00, 0x00, 0x00, 0x01, // 1 (21),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-22),
+				0x00, 0x00, 0x00, 0x01, // 1 (23),
+				0x00, 0x00, 0x00, 0x01, // 1 (24),
+				0x00, 0x00, 0x00, 0x01, // 1 (25),
+				0x00, 0x00, 0x00, 0x01, // 1 (26),
+				0x00, 0x00, 0x00, 0x01, // 1 (27),
+				0x00, 0x00, 0x00, 0x01, // 1 (28),
+				0x00, 0x00, 0x00, 0x01, // 1 (29),
+				0x00, 0x00, 0x00, 0x01, // 1 (2A),
+				0x00, 0x00, 0x00, 0x01, // 1 (2B),
+				0x00, 0x00, 0x00, 0x01, // 1 (2C),
+				0x00, 0x00, 0x00, 0x01, // 1 (2D),
+				0x00, 0x00, 0x00, 0x01, // 1 (2E),
+				0x00, 0x00, 0x00, 0x01, // 1 (2F),
+				0x00, 0x00, 0x00, 0x01, // 1 (30),
+				0x00, 0x00, 0x00, 0x01, // 1 (31),
+				0x00, 0x00, 0x00, 0x01, // 1 (32),
+				0x00, 0x00, 0x00, 0x01, // 1 (33),
+				0x00, 0x00, 0x00, 0x01, // 1 (34),
+				0x00, 0x00, 0x00, 0x01, // 1 (35),
+				0x00, 0x00, 0x00, 0x01, // 1 (36),
+				0x00, 0x00, 0x00, 0x01, // 1 (37),
+				0x00, 0x00, 0x00, 0x01, // 1 (38),
+				0x00, 0x00, 0x00, 0x01, // 1 (39),
+				0x00, 0x00, 0x00, 0x01, // 1 (3A),
+				0x00, 0x00, 0x00, 0x01, // 1 (3B),
+				0x00, 0x00, 0x00, 0x01, // 1 (3C),
+				0x00, 0x00, 0x00, 0x01, // 1 (3D),
+				0x00, 0x00, 0x00, 0x01, // 1 (3E),
+				0x00, 0x00, 0x00, 0x01, // 1 (3F),
+				0x00, 0x00, 0x00, 0x01, // 1 (40),
+				0x00, 0x00, 0x00, 0x01, // 1 (41),
+				0x00, 0x00, 0x00, 0x01, // 1 (42),
+				0x00, 0x00, 0x00, 0x01, // 1 (43),
+				0x00, 0x00, 0x00, 0x01, // 1 (44),
+				0x00, 0x00, 0x00, 0x01, // 1 (45),
+				0x00, 0x00, 0x00, 0x01, // 1 (46),
+				0x00, 0x00, 0x00, 0x01, // 1 (47),
+				0x00, 0x00, 0x00, 0x01, // 1 (48),
+				0x00, 0x00, 0x00, 0x01, // 1 (49),
+				0x00, 0x00, 0x00, 0x01, // 1 (4A),
+				0x00, 0x00, 0x00, 0x01, // 1 (4B),
+				0x00, 0x00, 0x00, 0x01, // 1 (4C),
+				0x00, 0x00, 0x00, 0x01, // 1 (4D),
+				0x00, 0x00, 0x00, 0x01, // 1 (4E),
+				0x00, 0x00, 0x00, 0x01, // 1 (4F),
+				0x00, 0x00, 0x00, 0x01, // 1 (50),
+				0x00, 0x00, 0x00, 0x01, // 1 (51),
+				0x00, 0x00, 0x00, 0x01, // 1 (52),
+				0x00, 0x00, 0x00, 0x01, // 1 (53),
+				0x00, 0x00, 0x00, 0x01, // 1 (54),
+				0x00, 0x00, 0x00, 0x01, // 1 (55),
+				0x00, 0x00, 0x00, 0x01, // 1 (56),
+				0x00, 0x00, 0x00, 0x01, // 1 (57),
+				0x00, 0x00, 0x00, 0x01, // 1 (58),
+				0x00, 0x00, 0x00, 0x01, // 1 (59),
+				0x00, 0x00, 0x00, 0x01, // 1 (5A),
+				0x00, 0x00, 0x00, 0x01, // 1 (5B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-5C),
+				0x00, 0x00, 0x00, 0x01, // 1 (5D),
+				0x00, 0x00, 0x00, 0x01, // 1 (5E),
+				0x00, 0x00, 0x00, 0x01, // 1 (5F),
+				0x00, 0x00, 0x00, 0x01, // 1 (60),
+				0x00, 0x00, 0x00, 0x01, // 1 (61),
+				0x00, 0x00, 0x00, 0x01, // 1 (62),
+				0x00, 0x00, 0x00, 0x01, // 1 (63),
+				0x00, 0x00, 0x00, 0x01, // 1 (64),
+				0x00, 0x00, 0x00, 0x01, // 1 (65),
+				0x00, 0x00, 0x00, 0x01, // 1 (66),
+				0x00, 0x00, 0x00, 0x01, // 1 (67),
+				0x00, 0x00, 0x00, 0x01, // 1 (68),
+				0x00, 0x00, 0x00, 0x01, // 1 (69),
+				0x00, 0x00, 0x00, 0x01, // 1 (6A),
+				0x00, 0x00, 0x00, 0x01, // 1 (6B),
+				0x00, 0x00, 0x00, 0x01, // 1 (6C),
+				0x00, 0x00, 0x00, 0x01, // 1 (6D),
+				0x00, 0x00, 0x00, 0x01, // 1 (6E),
+				0x00, 0x00, 0x00, 0x01, // 1 (6F),
+				0x00, 0x00, 0x00, 0x01, // 1 (70),
+				0x00, 0x00, 0x00, 0x01, // 1 (71),
+				0x00, 0x00, 0x00, 0x01, // 1 (72),
+				0x00, 0x00, 0x00, 0x01, // 1 (73),
+				0x00, 0x00, 0x00, 0x01, // 1 (74),
+				0x00, 0x00, 0x00, 0x01, // 1 (75),
+				0x00, 0x00, 0x00, 0x01, // 1 (76),
+				0x00, 0x00, 0x00, 0x01, // 1 (77),
+				0x00, 0x00, 0x00, 0x01, // 1 (78),
+				0x00, 0x00, 0x00, 0x01, // 1 (79),
+				0x00, 0x00, 0x00, 0x01, // 1 (7A),
+				0x00, 0x00, 0x00, 0x01, // 1 (7B),
+				0x00, 0x00, 0x00, 0x01, // 1 (7C),
+				0x00, 0x00, 0x00, 0x01, // 1 (7D),
+				0x00, 0x00, 0x00, 0x01, // 1 (7E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<byte> BaseWithoutTabEscapeLengthTableLittleEndian =>
+			new byte[]
+			{
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-00),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-01),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-02),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-03),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-04),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-05),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-06),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-07),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-62),
+				0x01, 0x00, 0x00, 0x00, // 1 (09),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-6E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-66),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-72),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0F),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-10),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-11),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-12),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-13),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-14),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-15),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-16),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-17),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-18),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-19),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1A),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1B),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1C),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1D),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1F),
+				0x01, 0x00, 0x00, 0x00, // 1 (20),
+				0x01, 0x00, 0x00, 0x00, // 1 (21),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-22),
+				0x01, 0x00, 0x00, 0x00, // 1 (23),
+				0x01, 0x00, 0x00, 0x00, // 1 (24),
+				0x01, 0x00, 0x00, 0x00, // 1 (25),
+				0x01, 0x00, 0x00, 0x00, // 1 (26),
+				0x01, 0x00, 0x00, 0x00, // 1 (27),
+				0x01, 0x00, 0x00, 0x00, // 1 (28),
+				0x01, 0x00, 0x00, 0x00, // 1 (29),
+				0x01, 0x00, 0x00, 0x00, // 1 (2A),
+				0x01, 0x00, 0x00, 0x00, // 1 (2B),
+				0x01, 0x00, 0x00, 0x00, // 1 (2C),
+				0x01, 0x00, 0x00, 0x00, // 1 (2D),
+				0x01, 0x00, 0x00, 0x00, // 1 (2E),
+				0x01, 0x00, 0x00, 0x00, // 1 (2F),
+				0x01, 0x00, 0x00, 0x00, // 1 (30),
+				0x01, 0x00, 0x00, 0x00, // 1 (31),
+				0x01, 0x00, 0x00, 0x00, // 1 (32),
+				0x01, 0x00, 0x00, 0x00, // 1 (33),
+				0x01, 0x00, 0x00, 0x00, // 1 (34),
+				0x01, 0x00, 0x00, 0x00, // 1 (35),
+				0x01, 0x00, 0x00, 0x00, // 1 (36),
+				0x01, 0x00, 0x00, 0x00, // 1 (37),
+				0x01, 0x00, 0x00, 0x00, // 1 (38),
+				0x01, 0x00, 0x00, 0x00, // 1 (39),
+				0x01, 0x00, 0x00, 0x00, // 1 (3A),
+				0x01, 0x00, 0x00, 0x00, // 1 (3B),
+				0x01, 0x00, 0x00, 0x00, // 1 (3C),
+				0x01, 0x00, 0x00, 0x00, // 1 (3D),
+				0x01, 0x00, 0x00, 0x00, // 1 (3E),
+				0x01, 0x00, 0x00, 0x00, // 1 (3F),
+				0x01, 0x00, 0x00, 0x00, // 1 (40),
+				0x01, 0x00, 0x00, 0x00, // 1 (41),
+				0x01, 0x00, 0x00, 0x00, // 1 (42),
+				0x01, 0x00, 0x00, 0x00, // 1 (43),
+				0x01, 0x00, 0x00, 0x00, // 1 (44),
+				0x01, 0x00, 0x00, 0x00, // 1 (45),
+				0x01, 0x00, 0x00, 0x00, // 1 (46),
+				0x01, 0x00, 0x00, 0x00, // 1 (47),
+				0x01, 0x00, 0x00, 0x00, // 1 (48),
+				0x01, 0x00, 0x00, 0x00, // 1 (49),
+				0x01, 0x00, 0x00, 0x00, // 1 (4A),
+				0x01, 0x00, 0x00, 0x00, // 1 (4B),
+				0x01, 0x00, 0x00, 0x00, // 1 (4C),
+				0x01, 0x00, 0x00, 0x00, // 1 (4D),
+				0x01, 0x00, 0x00, 0x00, // 1 (4E),
+				0x01, 0x00, 0x00, 0x00, // 1 (4F),
+				0x01, 0x00, 0x00, 0x00, // 1 (50),
+				0x01, 0x00, 0x00, 0x00, // 1 (51),
+				0x01, 0x00, 0x00, 0x00, // 1 (52),
+				0x01, 0x00, 0x00, 0x00, // 1 (53),
+				0x01, 0x00, 0x00, 0x00, // 1 (54),
+				0x01, 0x00, 0x00, 0x00, // 1 (55),
+				0x01, 0x00, 0x00, 0x00, // 1 (56),
+				0x01, 0x00, 0x00, 0x00, // 1 (57),
+				0x01, 0x00, 0x00, 0x00, // 1 (58),
+				0x01, 0x00, 0x00, 0x00, // 1 (59),
+				0x01, 0x00, 0x00, 0x00, // 1 (5A),
+				0x01, 0x00, 0x00, 0x00, // 1 (5B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-5C),
+				0x01, 0x00, 0x00, 0x00, // 1 (5D),
+				0x01, 0x00, 0x00, 0x00, // 1 (5E),
+				0x01, 0x00, 0x00, 0x00, // 1 (5F),
+				0x01, 0x00, 0x00, 0x00, // 1 (60),
+				0x01, 0x00, 0x00, 0x00, // 1 (61),
+				0x01, 0x00, 0x00, 0x00, // 1 (62),
+				0x01, 0x00, 0x00, 0x00, // 1 (63),
+				0x01, 0x00, 0x00, 0x00, // 1 (64),
+				0x01, 0x00, 0x00, 0x00, // 1 (65),
+				0x01, 0x00, 0x00, 0x00, // 1 (66),
+				0x01, 0x00, 0x00, 0x00, // 1 (67),
+				0x01, 0x00, 0x00, 0x00, // 1 (68),
+				0x01, 0x00, 0x00, 0x00, // 1 (69),
+				0x01, 0x00, 0x00, 0x00, // 1 (6A),
+				0x01, 0x00, 0x00, 0x00, // 1 (6B),
+				0x01, 0x00, 0x00, 0x00, // 1 (6C),
+				0x01, 0x00, 0x00, 0x00, // 1 (6D),
+				0x01, 0x00, 0x00, 0x00, // 1 (6E),
+				0x01, 0x00, 0x00, 0x00, // 1 (6F),
+				0x01, 0x00, 0x00, 0x00, // 1 (70),
+				0x01, 0x00, 0x00, 0x00, // 1 (71),
+				0x01, 0x00, 0x00, 0x00, // 1 (72),
+				0x01, 0x00, 0x00, 0x00, // 1 (73),
+				0x01, 0x00, 0x00, 0x00, // 1 (74),
+				0x01, 0x00, 0x00, 0x00, // 1 (75),
+				0x01, 0x00, 0x00, 0x00, // 1 (76),
+				0x01, 0x00, 0x00, 0x00, // 1 (77),
+				0x01, 0x00, 0x00, 0x00, // 1 (78),
+				0x01, 0x00, 0x00, 0x00, // 1 (79),
+				0x01, 0x00, 0x00, 0x00, // 1 (7A),
+				0x01, 0x00, 0x00, 0x00, // 1 (7B),
+				0x01, 0x00, 0x00, 0x00, // 1 (7C),
+				0x01, 0x00, 0x00, 0x00, // 1 (7D),
+				0x01, 0x00, 0x00, 0x00, // 1 (7E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<ulong> BaseWithHtmlCharsEscapeTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, ulong>(BaseWithHtmlCharsEscapeTableLittleEndian) :
+				MemoryMarshal.Cast<byte, ulong>(BaseWithHtmlCharsEscapeTableBigEndian);
+
+		public static ReadOnlySpan<int> BaseWithHtmlCharsEscapeLengthTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, int>(BaseWithHtmlCharsEscapeLengthTableLittleEndian) :
+				MemoryMarshal.Cast<byte, int>(BaseWithHtmlCharsEscapeLengthTableBigEndian);
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsEscapeTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000000000,
+				0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000010000,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000020000,
+				0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000030000,
+				0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000040000,
+				0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000050000,
+				0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000060000,
+				0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000070000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x5C, // 0x5C62000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x5C, // 0x5C74000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x5C, // 0x5C6E000000000000,
+				0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000B0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x5C, // 0x5C66000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x5C, // 0x5C72000000000000,
+				0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000E0000,
+				0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000F0000,
+				0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000100000,
+				0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000110000,
+				0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000120000,
+				0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000130000,
+				0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000140000,
+				0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000150000,
+				0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000160000,
+				0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000170000,
+				0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000180000,
+				0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000190000,
+				0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001A0000,
+				0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001B0000,
+				0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001C0000,
+				0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001D0000,
+				0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001E0000,
+				0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001F0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, // 0x2000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, // 0x2100000000000000,
+				0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000220000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, // 0x2300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, // 0x2400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, // 0x2500000000000000,
+				0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000260000,
+				0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000270000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, // 0x2800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, // 0x2900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2A, // 0x2A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, // 0x2B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, // 0x2C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2D, // 0x2D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, // 0x2E00000000000000,
+				0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000002F0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, // 0x3000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, // 0x3100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, // 0x3200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, // 0x3300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, // 0x3400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, // 0x3500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, // 0x3600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, // 0x3700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, // 0x3800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, // 0x3900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3A, // 0x3A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, // 0x3B00000000000000,
+				0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000003C0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, // 0x3D00000000000000,
+				0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000003E0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, // 0x3F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, // 0x4000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, // 0x4100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, // 0x4200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, // 0x4300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, // 0x4400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, // 0x4500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, // 0x4600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, // 0x4700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, // 0x4800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, // 0x4900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, // 0x4A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4B, // 0x4B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, // 0x4C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, // 0x4D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, // 0x4E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, // 0x4F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, // 0x5000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, // 0x5100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, // 0x5200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, // 0x5300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, // 0x5400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, // 0x5500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, // 0x5600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, // 0x5700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, // 0x5800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, // 0x5900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, // 0x5A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5B, // 0x5B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0x5C, // 0x5C5C000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, // 0x5D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5E, // 0x5E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, // 0x5F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, // 0x6000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, // 0x6100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, // 0x6200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, // 0x6300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, // 0x6400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, // 0x6500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, // 0x6600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, // 0x6700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, // 0x6800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, // 0x6900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6A, // 0x6A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6B, // 0x6B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, // 0x6C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6D, // 0x6D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, // 0x6E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6F, // 0x6F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, // 0x7000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, // 0x7100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, // 0x7200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, // 0x7300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, // 0x7400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, // 0x7500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, // 0x7600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, // 0x7700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, // 0x7800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79, // 0x7900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, // 0x7A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, // 0x7B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, // 0x7C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7D, // 0x7D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, // 0x7E00000000000000,
+				0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000007F0000,
+			};
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsEscapeTableLittleEndian =>
+			new byte[]
+			{
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // 0x000001000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, // 0x000002000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // 0x000003000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, // 0x000004000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, // 0x000005000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, // 0x000006000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, // 0x000007000000755C,
+				0x5C, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000625C,
+				0x5C, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000745C,
+				0x5C, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000006E5C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, // 0x00000B000000755C,
+				0x5C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000665C,
+				0x5C, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000725C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, // 0x00000E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, // 0x00000F000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, // 0x000010000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, // 0x000011000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, // 0x000012000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, // 0x000013000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, // 0x000014000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, // 0x000015000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, // 0x000016000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, // 0x000017000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, // 0x000018000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, // 0x000019000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, // 0x00001A000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, // 0x00001B000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, // 0x00001C000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, // 0x00001D000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, // 0x00001E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, // 0x00001F000000755C,
+				0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000020,
+				0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000021,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // 0x000022000000755C,
+				0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000023,
+				0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000024,
+				0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000025,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, // 0x000026000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, // 0x000027000000755C,
+				0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000028,
+				0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000029,
+				0x2A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002A,
+				0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002B,
+				0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002C,
+				0x2D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002D,
+				0x2E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002E,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, // 0x00002F000000755C,
+				0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000030,
+				0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000031,
+				0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000032,
+				0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000033,
+				0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000034,
+				0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000035,
+				0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000036,
+				0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000037,
+				0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000038,
+				0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000039,
+				0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003A,
+				0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003B,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, // 0x00003C000000755C,
+				0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003D,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, // 0x00003E000000755C,
+				0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003F,
+				0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000040,
+				0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000041,
+				0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000042,
+				0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000043,
+				0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000044,
+				0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000045,
+				0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000046,
+				0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000047,
+				0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000048,
+				0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000049,
+				0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004A,
+				0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004B,
+				0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004C,
+				0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004D,
+				0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004E,
+				0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004F,
+				0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000050,
+				0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000051,
+				0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000052,
+				0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000053,
+				0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000054,
+				0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000055,
+				0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000056,
+				0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000057,
+				0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000058,
+				0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000059,
+				0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005A,
+				0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005B,
+				0x5C, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000005C5C,
+				0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005D,
+				0x5E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005E,
+				0x5F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005F,
+				0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000060,
+				0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000061,
+				0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000062,
+				0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000063,
+				0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000064,
+				0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000065,
+				0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000066,
+				0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000067,
+				0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000068,
+				0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000069,
+				0x6A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006A,
+				0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006B,
+				0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006C,
+				0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006D,
+				0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006E,
+				0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006F,
+				0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000070,
+				0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000071,
+				0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000072,
+				0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000073,
+				0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000074,
+				0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000075,
+				0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000076,
+				0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000077,
+				0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000078,
+				0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000079,
+				0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007A,
+				0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007B,
+				0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007C,
+				0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007D,
+				0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007E,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, // 0x00007F000000755C,
+			};
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsEscapeLengthTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-00),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-01),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-02),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-03),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-04),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-05),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-06),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-07),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-62),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-74),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-6E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-66),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-72),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0F),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-10),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-11),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-12),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-13),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-14),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-15),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-16),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-17),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-18),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-19),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1A),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1B),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1C),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1D),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1F),
+				0x00, 0x00, 0x00, 0x01, // 1 (20),
+				0x00, 0x00, 0x00, 0x01, // 1 (21),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-22),
+				0x00, 0x00, 0x00, 0x01, // 1 (23),
+				0x00, 0x00, 0x00, 0x01, // 1 (24),
+				0x00, 0x00, 0x00, 0x01, // 1 (25),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-26),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-27),
+				0x00, 0x00, 0x00, 0x01, // 1 (28),
+				0x00, 0x00, 0x00, 0x01, // 1 (29),
+				0x00, 0x00, 0x00, 0x01, // 1 (2A),
+				0x00, 0x00, 0x00, 0x01, // 1 (2B),
+				0x00, 0x00, 0x00, 0x01, // 1 (2C),
+				0x00, 0x00, 0x00, 0x01, // 1 (2D),
+				0x00, 0x00, 0x00, 0x01, // 1 (2E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-2F),
+				0x00, 0x00, 0x00, 0x01, // 1 (30),
+				0x00, 0x00, 0x00, 0x01, // 1 (31),
+				0x00, 0x00, 0x00, 0x01, // 1 (32),
+				0x00, 0x00, 0x00, 0x01, // 1 (33),
+				0x00, 0x00, 0x00, 0x01, // 1 (34),
+				0x00, 0x00, 0x00, 0x01, // 1 (35),
+				0x00, 0x00, 0x00, 0x01, // 1 (36),
+				0x00, 0x00, 0x00, 0x01, // 1 (37),
+				0x00, 0x00, 0x00, 0x01, // 1 (38),
+				0x00, 0x00, 0x00, 0x01, // 1 (39),
+				0x00, 0x00, 0x00, 0x01, // 1 (3A),
+				0x00, 0x00, 0x00, 0x01, // 1 (3B),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-3C),
+				0x00, 0x00, 0x00, 0x01, // 1 (3D),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-3E),
+				0x00, 0x00, 0x00, 0x01, // 1 (3F),
+				0x00, 0x00, 0x00, 0x01, // 1 (40),
+				0x00, 0x00, 0x00, 0x01, // 1 (41),
+				0x00, 0x00, 0x00, 0x01, // 1 (42),
+				0x00, 0x00, 0x00, 0x01, // 1 (43),
+				0x00, 0x00, 0x00, 0x01, // 1 (44),
+				0x00, 0x00, 0x00, 0x01, // 1 (45),
+				0x00, 0x00, 0x00, 0x01, // 1 (46),
+				0x00, 0x00, 0x00, 0x01, // 1 (47),
+				0x00, 0x00, 0x00, 0x01, // 1 (48),
+				0x00, 0x00, 0x00, 0x01, // 1 (49),
+				0x00, 0x00, 0x00, 0x01, // 1 (4A),
+				0x00, 0x00, 0x00, 0x01, // 1 (4B),
+				0x00, 0x00, 0x00, 0x01, // 1 (4C),
+				0x00, 0x00, 0x00, 0x01, // 1 (4D),
+				0x00, 0x00, 0x00, 0x01, // 1 (4E),
+				0x00, 0x00, 0x00, 0x01, // 1 (4F),
+				0x00, 0x00, 0x00, 0x01, // 1 (50),
+				0x00, 0x00, 0x00, 0x01, // 1 (51),
+				0x00, 0x00, 0x00, 0x01, // 1 (52),
+				0x00, 0x00, 0x00, 0x01, // 1 (53),
+				0x00, 0x00, 0x00, 0x01, // 1 (54),
+				0x00, 0x00, 0x00, 0x01, // 1 (55),
+				0x00, 0x00, 0x00, 0x01, // 1 (56),
+				0x00, 0x00, 0x00, 0x01, // 1 (57),
+				0x00, 0x00, 0x00, 0x01, // 1 (58),
+				0x00, 0x00, 0x00, 0x01, // 1 (59),
+				0x00, 0x00, 0x00, 0x01, // 1 (5A),
+				0x00, 0x00, 0x00, 0x01, // 1 (5B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-5C),
+				0x00, 0x00, 0x00, 0x01, // 1 (5D),
+				0x00, 0x00, 0x00, 0x01, // 1 (5E),
+				0x00, 0x00, 0x00, 0x01, // 1 (5F),
+				0x00, 0x00, 0x00, 0x01, // 1 (60),
+				0x00, 0x00, 0x00, 0x01, // 1 (61),
+				0x00, 0x00, 0x00, 0x01, // 1 (62),
+				0x00, 0x00, 0x00, 0x01, // 1 (63),
+				0x00, 0x00, 0x00, 0x01, // 1 (64),
+				0x00, 0x00, 0x00, 0x01, // 1 (65),
+				0x00, 0x00, 0x00, 0x01, // 1 (66),
+				0x00, 0x00, 0x00, 0x01, // 1 (67),
+				0x00, 0x00, 0x00, 0x01, // 1 (68),
+				0x00, 0x00, 0x00, 0x01, // 1 (69),
+				0x00, 0x00, 0x00, 0x01, // 1 (6A),
+				0x00, 0x00, 0x00, 0x01, // 1 (6B),
+				0x00, 0x00, 0x00, 0x01, // 1 (6C),
+				0x00, 0x00, 0x00, 0x01, // 1 (6D),
+				0x00, 0x00, 0x00, 0x01, // 1 (6E),
+				0x00, 0x00, 0x00, 0x01, // 1 (6F),
+				0x00, 0x00, 0x00, 0x01, // 1 (70),
+				0x00, 0x00, 0x00, 0x01, // 1 (71),
+				0x00, 0x00, 0x00, 0x01, // 1 (72),
+				0x00, 0x00, 0x00, 0x01, // 1 (73),
+				0x00, 0x00, 0x00, 0x01, // 1 (74),
+				0x00, 0x00, 0x00, 0x01, // 1 (75),
+				0x00, 0x00, 0x00, 0x01, // 1 (76),
+				0x00, 0x00, 0x00, 0x01, // 1 (77),
+				0x00, 0x00, 0x00, 0x01, // 1 (78),
+				0x00, 0x00, 0x00, 0x01, // 1 (79),
+				0x00, 0x00, 0x00, 0x01, // 1 (7A),
+				0x00, 0x00, 0x00, 0x01, // 1 (7B),
+				0x00, 0x00, 0x00, 0x01, // 1 (7C),
+				0x00, 0x00, 0x00, 0x01, // 1 (7D),
+				0x00, 0x00, 0x00, 0x01, // 1 (7E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsEscapeLengthTableLittleEndian =>
+			new byte[]
+			{
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-00),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-01),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-02),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-03),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-04),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-05),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-06),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-07),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-62),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-74),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-6E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-66),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-72),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0F),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-10),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-11),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-12),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-13),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-14),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-15),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-16),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-17),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-18),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-19),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1A),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1B),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1C),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1D),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1F),
+				0x01, 0x00, 0x00, 0x00, // 1 (20),
+				0x01, 0x00, 0x00, 0x00, // 1 (21),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-22),
+				0x01, 0x00, 0x00, 0x00, // 1 (23),
+				0x01, 0x00, 0x00, 0x00, // 1 (24),
+				0x01, 0x00, 0x00, 0x00, // 1 (25),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-26),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-27),
+				0x01, 0x00, 0x00, 0x00, // 1 (28),
+				0x01, 0x00, 0x00, 0x00, // 1 (29),
+				0x01, 0x00, 0x00, 0x00, // 1 (2A),
+				0x01, 0x00, 0x00, 0x00, // 1 (2B),
+				0x01, 0x00, 0x00, 0x00, // 1 (2C),
+				0x01, 0x00, 0x00, 0x00, // 1 (2D),
+				0x01, 0x00, 0x00, 0x00, // 1 (2E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-2F),
+				0x01, 0x00, 0x00, 0x00, // 1 (30),
+				0x01, 0x00, 0x00, 0x00, // 1 (31),
+				0x01, 0x00, 0x00, 0x00, // 1 (32),
+				0x01, 0x00, 0x00, 0x00, // 1 (33),
+				0x01, 0x00, 0x00, 0x00, // 1 (34),
+				0x01, 0x00, 0x00, 0x00, // 1 (35),
+				0x01, 0x00, 0x00, 0x00, // 1 (36),
+				0x01, 0x00, 0x00, 0x00, // 1 (37),
+				0x01, 0x00, 0x00, 0x00, // 1 (38),
+				0x01, 0x00, 0x00, 0x00, // 1 (39),
+				0x01, 0x00, 0x00, 0x00, // 1 (3A),
+				0x01, 0x00, 0x00, 0x00, // 1 (3B),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-3C),
+				0x01, 0x00, 0x00, 0x00, // 1 (3D),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-3E),
+				0x01, 0x00, 0x00, 0x00, // 1 (3F),
+				0x01, 0x00, 0x00, 0x00, // 1 (40),
+				0x01, 0x00, 0x00, 0x00, // 1 (41),
+				0x01, 0x00, 0x00, 0x00, // 1 (42),
+				0x01, 0x00, 0x00, 0x00, // 1 (43),
+				0x01, 0x00, 0x00, 0x00, // 1 (44),
+				0x01, 0x00, 0x00, 0x00, // 1 (45),
+				0x01, 0x00, 0x00, 0x00, // 1 (46),
+				0x01, 0x00, 0x00, 0x00, // 1 (47),
+				0x01, 0x00, 0x00, 0x00, // 1 (48),
+				0x01, 0x00, 0x00, 0x00, // 1 (49),
+				0x01, 0x00, 0x00, 0x00, // 1 (4A),
+				0x01, 0x00, 0x00, 0x00, // 1 (4B),
+				0x01, 0x00, 0x00, 0x00, // 1 (4C),
+				0x01, 0x00, 0x00, 0x00, // 1 (4D),
+				0x01, 0x00, 0x00, 0x00, // 1 (4E),
+				0x01, 0x00, 0x00, 0x00, // 1 (4F),
+				0x01, 0x00, 0x00, 0x00, // 1 (50),
+				0x01, 0x00, 0x00, 0x00, // 1 (51),
+				0x01, 0x00, 0x00, 0x00, // 1 (52),
+				0x01, 0x00, 0x00, 0x00, // 1 (53),
+				0x01, 0x00, 0x00, 0x00, // 1 (54),
+				0x01, 0x00, 0x00, 0x00, // 1 (55),
+				0x01, 0x00, 0x00, 0x00, // 1 (56),
+				0x01, 0x00, 0x00, 0x00, // 1 (57),
+				0x01, 0x00, 0x00, 0x00, // 1 (58),
+				0x01, 0x00, 0x00, 0x00, // 1 (59),
+				0x01, 0x00, 0x00, 0x00, // 1 (5A),
+				0x01, 0x00, 0x00, 0x00, // 1 (5B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-5C),
+				0x01, 0x00, 0x00, 0x00, // 1 (5D),
+				0x01, 0x00, 0x00, 0x00, // 1 (5E),
+				0x01, 0x00, 0x00, 0x00, // 1 (5F),
+				0x01, 0x00, 0x00, 0x00, // 1 (60),
+				0x01, 0x00, 0x00, 0x00, // 1 (61),
+				0x01, 0x00, 0x00, 0x00, // 1 (62),
+				0x01, 0x00, 0x00, 0x00, // 1 (63),
+				0x01, 0x00, 0x00, 0x00, // 1 (64),
+				0x01, 0x00, 0x00, 0x00, // 1 (65),
+				0x01, 0x00, 0x00, 0x00, // 1 (66),
+				0x01, 0x00, 0x00, 0x00, // 1 (67),
+				0x01, 0x00, 0x00, 0x00, // 1 (68),
+				0x01, 0x00, 0x00, 0x00, // 1 (69),
+				0x01, 0x00, 0x00, 0x00, // 1 (6A),
+				0x01, 0x00, 0x00, 0x00, // 1 (6B),
+				0x01, 0x00, 0x00, 0x00, // 1 (6C),
+				0x01, 0x00, 0x00, 0x00, // 1 (6D),
+				0x01, 0x00, 0x00, 0x00, // 1 (6E),
+				0x01, 0x00, 0x00, 0x00, // 1 (6F),
+				0x01, 0x00, 0x00, 0x00, // 1 (70),
+				0x01, 0x00, 0x00, 0x00, // 1 (71),
+				0x01, 0x00, 0x00, 0x00, // 1 (72),
+				0x01, 0x00, 0x00, 0x00, // 1 (73),
+				0x01, 0x00, 0x00, 0x00, // 1 (74),
+				0x01, 0x00, 0x00, 0x00, // 1 (75),
+				0x01, 0x00, 0x00, 0x00, // 1 (76),
+				0x01, 0x00, 0x00, 0x00, // 1 (77),
+				0x01, 0x00, 0x00, 0x00, // 1 (78),
+				0x01, 0x00, 0x00, 0x00, // 1 (79),
+				0x01, 0x00, 0x00, 0x00, // 1 (7A),
+				0x01, 0x00, 0x00, 0x00, // 1 (7B),
+				0x01, 0x00, 0x00, 0x00, // 1 (7C),
+				0x01, 0x00, 0x00, 0x00, // 1 (7D),
+				0x01, 0x00, 0x00, 0x00, // 1 (7E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<ulong> BaseWithHtmlCharsWithoutTabEscapeTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, ulong>(BaseWithHtmlCharsWithoutTabEscapeTableLittleEndian) :
+				MemoryMarshal.Cast<byte, ulong>(BaseWithHtmlCharsWithoutTabEscapeTableBigEndian);
+
+		public static ReadOnlySpan<int> BaseWithHtmlCharsWithoutTabEscapeLengthTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, int>(BaseWithHtmlCharsWithoutTabEscapeLengthTableLittleEndian) :
+				MemoryMarshal.Cast<byte, int>(BaseWithHtmlCharsWithoutTabEscapeLengthTableBigEndian);
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsWithoutTabEscapeTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000000000,
+				0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000010000,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000020000,
+				0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000030000,
+				0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000040000,
+				0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000050000,
+				0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000060000,
+				0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000070000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x5C, // 0x5C62000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, // 0x0900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x5C, // 0x5C6E000000000000,
+				0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000B0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x5C, // 0x5C66000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x5C, // 0x5C72000000000000,
+				0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000E0000,
+				0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000000F0000,
+				0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000100000,
+				0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000110000,
+				0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000120000,
+				0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000130000,
+				0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000140000,
+				0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000150000,
+				0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000160000,
+				0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000170000,
+				0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000180000,
+				0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000190000,
+				0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001A0000,
+				0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001B0000,
+				0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001C0000,
+				0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001D0000,
+				0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001E0000,
+				0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000001F0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, // 0x2000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, // 0x2100000000000000,
+				0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000220000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, // 0x2300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, // 0x2400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, // 0x2500000000000000,
+				0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000260000,
+				0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C75000000270000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, // 0x2800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, // 0x2900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2A, // 0x2A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2B, // 0x2B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, // 0x2C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2D, // 0x2D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, // 0x2E00000000000000,
+				0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000002F0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, // 0x3000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, // 0x3100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, // 0x3200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, // 0x3300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, // 0x3400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, // 0x3500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, // 0x3600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, // 0x3700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, // 0x3800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, // 0x3900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3A, // 0x3A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3B, // 0x3B00000000000000,
+				0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000003C0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, // 0x3D00000000000000,
+				0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000003E0000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, // 0x3F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, // 0x4000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, // 0x4100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, // 0x4200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, // 0x4300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, // 0x4400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, // 0x4500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, // 0x4600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, // 0x4700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, // 0x4800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, // 0x4900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, // 0x4A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4B, // 0x4B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4C, // 0x4C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, // 0x4D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, // 0x4E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4F, // 0x4F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, // 0x5000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, // 0x5100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, // 0x5200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, // 0x5300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, // 0x5400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, // 0x5500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, // 0x5600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, // 0x5700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, // 0x5800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, // 0x5900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, // 0x5A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5B, // 0x5B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0x5C, // 0x5C5C000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, // 0x5D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5E, // 0x5E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, // 0x5F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, // 0x6000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, // 0x6100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, // 0x6200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, // 0x6300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, // 0x6400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, // 0x6500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, // 0x6600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, // 0x6700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, // 0x6800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, // 0x6900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6A, // 0x6A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6B, // 0x6B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, // 0x6C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6D, // 0x6D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, // 0x6E00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6F, // 0x6F00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, // 0x7000000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, // 0x7100000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, // 0x7200000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, // 0x7300000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, // 0x7400000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, // 0x7500000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, // 0x7600000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, // 0x7700000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, // 0x7800000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79, // 0x7900000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, // 0x7A00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, // 0x7B00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, // 0x7C00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7D, // 0x7D00000000000000,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, // 0x7E00000000000000,
+				0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x75, 0x5C, // 0x5C750000007F0000,
+			};
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsWithoutTabEscapeTableLittleEndian =>
+			new byte[]
+			{
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // 0x000001000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, // 0x000002000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, // 0x000003000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, // 0x000004000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, // 0x000005000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, // 0x000006000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, // 0x000007000000755C,
+				0x5C, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000625C,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000009,
+				0x5C, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000006E5C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, // 0x00000B000000755C,
+				0x5C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000665C,
+				0x5C, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000725C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, // 0x00000E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, // 0x00000F000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, // 0x000010000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, // 0x000011000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, // 0x000012000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, // 0x000013000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, // 0x000014000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, // 0x000015000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, // 0x000016000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, // 0x000017000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, // 0x000018000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, // 0x000019000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, // 0x00001A000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, // 0x00001B000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, // 0x00001C000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, // 0x00001D000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, // 0x00001E000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, // 0x00001F000000755C,
+				0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000020,
+				0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000021,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, // 0x000022000000755C,
+				0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000023,
+				0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000024,
+				0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000025,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, // 0x000026000000755C,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, // 0x000027000000755C,
+				0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000028,
+				0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000029,
+				0x2A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002A,
+				0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002B,
+				0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002C,
+				0x2D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002D,
+				0x2E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000002E,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, // 0x00002F000000755C,
+				0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000030,
+				0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000031,
+				0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000032,
+				0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000033,
+				0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000034,
+				0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000035,
+				0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000036,
+				0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000037,
+				0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000038,
+				0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000039,
+				0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003A,
+				0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003B,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, // 0x00003C000000755C,
+				0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003D,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, // 0x00003E000000755C,
+				0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000003F,
+				0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000040,
+				0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000041,
+				0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000042,
+				0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000043,
+				0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000044,
+				0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000045,
+				0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000046,
+				0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000047,
+				0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000048,
+				0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000049,
+				0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004A,
+				0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004B,
+				0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004C,
+				0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004D,
+				0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004E,
+				0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000004F,
+				0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000050,
+				0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000051,
+				0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000052,
+				0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000053,
+				0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000054,
+				0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000055,
+				0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000056,
+				0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000057,
+				0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000058,
+				0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000059,
+				0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005A,
+				0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005B,
+				0x5C, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000005C5C,
+				0x5D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005D,
+				0x5E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005E,
+				0x5F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000005F,
+				0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000060,
+				0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000061,
+				0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000062,
+				0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000063,
+				0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000064,
+				0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000065,
+				0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000066,
+				0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000067,
+				0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000068,
+				0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000069,
+				0x6A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006A,
+				0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006B,
+				0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006C,
+				0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006D,
+				0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006E,
+				0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000006F,
+				0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000070,
+				0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000071,
+				0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000072,
+				0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000073,
+				0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000074,
+				0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000075,
+				0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000076,
+				0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000077,
+				0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000078,
+				0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x0000000000000079,
+				0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007A,
+				0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007B,
+				0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007C,
+				0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007D,
+				0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x000000000000007E,
+				0x5C, 0x75, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, // 0x00007F000000755C,
+			};
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsWithoutTabEscapeLengthTableBigEndian =>
+			new byte[]
+			{
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-00),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-01),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-02),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-03),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-04),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-05),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-06),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-07),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-62),
+				0x00, 0x00, 0x00, 0x01, // 1 (09),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-6E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-66),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-72),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-0F),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-10),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-11),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-12),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-13),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-14),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-15),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-16),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-17),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-18),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-19),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1A),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1B),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1C),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1D),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-1F),
+				0x00, 0x00, 0x00, 0x01, // 1 (20),
+				0x00, 0x00, 0x00, 0x01, // 1 (21),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-22),
+				0x00, 0x00, 0x00, 0x01, // 1 (23),
+				0x00, 0x00, 0x00, 0x01, // 1 (24),
+				0x00, 0x00, 0x00, 0x01, // 1 (25),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-26),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-27),
+				0x00, 0x00, 0x00, 0x01, // 1 (28),
+				0x00, 0x00, 0x00, 0x01, // 1 (29),
+				0x00, 0x00, 0x00, 0x01, // 1 (2A),
+				0x00, 0x00, 0x00, 0x01, // 1 (2B),
+				0x00, 0x00, 0x00, 0x01, // 1 (2C),
+				0x00, 0x00, 0x00, 0x01, // 1 (2D),
+				0x00, 0x00, 0x00, 0x01, // 1 (2E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-2F),
+				0x00, 0x00, 0x00, 0x01, // 1 (30),
+				0x00, 0x00, 0x00, 0x01, // 1 (31),
+				0x00, 0x00, 0x00, 0x01, // 1 (32),
+				0x00, 0x00, 0x00, 0x01, // 1 (33),
+				0x00, 0x00, 0x00, 0x01, // 1 (34),
+				0x00, 0x00, 0x00, 0x01, // 1 (35),
+				0x00, 0x00, 0x00, 0x01, // 1 (36),
+				0x00, 0x00, 0x00, 0x01, // 1 (37),
+				0x00, 0x00, 0x00, 0x01, // 1 (38),
+				0x00, 0x00, 0x00, 0x01, // 1 (39),
+				0x00, 0x00, 0x00, 0x01, // 1 (3A),
+				0x00, 0x00, 0x00, 0x01, // 1 (3B),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-3C),
+				0x00, 0x00, 0x00, 0x01, // 1 (3D),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-3E),
+				0x00, 0x00, 0x00, 0x01, // 1 (3F),
+				0x00, 0x00, 0x00, 0x01, // 1 (40),
+				0x00, 0x00, 0x00, 0x01, // 1 (41),
+				0x00, 0x00, 0x00, 0x01, // 1 (42),
+				0x00, 0x00, 0x00, 0x01, // 1 (43),
+				0x00, 0x00, 0x00, 0x01, // 1 (44),
+				0x00, 0x00, 0x00, 0x01, // 1 (45),
+				0x00, 0x00, 0x00, 0x01, // 1 (46),
+				0x00, 0x00, 0x00, 0x01, // 1 (47),
+				0x00, 0x00, 0x00, 0x01, // 1 (48),
+				0x00, 0x00, 0x00, 0x01, // 1 (49),
+				0x00, 0x00, 0x00, 0x01, // 1 (4A),
+				0x00, 0x00, 0x00, 0x01, // 1 (4B),
+				0x00, 0x00, 0x00, 0x01, // 1 (4C),
+				0x00, 0x00, 0x00, 0x01, // 1 (4D),
+				0x00, 0x00, 0x00, 0x01, // 1 (4E),
+				0x00, 0x00, 0x00, 0x01, // 1 (4F),
+				0x00, 0x00, 0x00, 0x01, // 1 (50),
+				0x00, 0x00, 0x00, 0x01, // 1 (51),
+				0x00, 0x00, 0x00, 0x01, // 1 (52),
+				0x00, 0x00, 0x00, 0x01, // 1 (53),
+				0x00, 0x00, 0x00, 0x01, // 1 (54),
+				0x00, 0x00, 0x00, 0x01, // 1 (55),
+				0x00, 0x00, 0x00, 0x01, // 1 (56),
+				0x00, 0x00, 0x00, 0x01, // 1 (57),
+				0x00, 0x00, 0x00, 0x01, // 1 (58),
+				0x00, 0x00, 0x00, 0x01, // 1 (59),
+				0x00, 0x00, 0x00, 0x01, // 1 (5A),
+				0x00, 0x00, 0x00, 0x01, // 1 (5B),
+				0x00, 0x00, 0x00, 0x02, // 2 (5C-5C),
+				0x00, 0x00, 0x00, 0x01, // 1 (5D),
+				0x00, 0x00, 0x00, 0x01, // 1 (5E),
+				0x00, 0x00, 0x00, 0x01, // 1 (5F),
+				0x00, 0x00, 0x00, 0x01, // 1 (60),
+				0x00, 0x00, 0x00, 0x01, // 1 (61),
+				0x00, 0x00, 0x00, 0x01, // 1 (62),
+				0x00, 0x00, 0x00, 0x01, // 1 (63),
+				0x00, 0x00, 0x00, 0x01, // 1 (64),
+				0x00, 0x00, 0x00, 0x01, // 1 (65),
+				0x00, 0x00, 0x00, 0x01, // 1 (66),
+				0x00, 0x00, 0x00, 0x01, // 1 (67),
+				0x00, 0x00, 0x00, 0x01, // 1 (68),
+				0x00, 0x00, 0x00, 0x01, // 1 (69),
+				0x00, 0x00, 0x00, 0x01, // 1 (6A),
+				0x00, 0x00, 0x00, 0x01, // 1 (6B),
+				0x00, 0x00, 0x00, 0x01, // 1 (6C),
+				0x00, 0x00, 0x00, 0x01, // 1 (6D),
+				0x00, 0x00, 0x00, 0x01, // 1 (6E),
+				0x00, 0x00, 0x00, 0x01, // 1 (6F),
+				0x00, 0x00, 0x00, 0x01, // 1 (70),
+				0x00, 0x00, 0x00, 0x01, // 1 (71),
+				0x00, 0x00, 0x00, 0x01, // 1 (72),
+				0x00, 0x00, 0x00, 0x01, // 1 (73),
+				0x00, 0x00, 0x00, 0x01, // 1 (74),
+				0x00, 0x00, 0x00, 0x01, // 1 (75),
+				0x00, 0x00, 0x00, 0x01, // 1 (76),
+				0x00, 0x00, 0x00, 0x01, // 1 (77),
+				0x00, 0x00, 0x00, 0x01, // 1 (78),
+				0x00, 0x00, 0x00, 0x01, // 1 (79),
+				0x00, 0x00, 0x00, 0x01, // 1 (7A),
+				0x00, 0x00, 0x00, 0x01, // 1 (7B),
+				0x00, 0x00, 0x00, 0x01, // 1 (7C),
+				0x00, 0x00, 0x00, 0x01, // 1 (7D),
+				0x00, 0x00, 0x00, 0x01, // 1 (7E),
+				0x00, 0x00, 0x00, 0x06, // 6 (5C-75-00-00-00-7F),
+			};
+
+		public static ReadOnlySpan<byte> BaseWithHtmlCharsWithoutTabEscapeLengthTableLittleEndian =>
+			new byte[]
+			{
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-00),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-01),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-02),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-03),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-04),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-05),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-06),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-07),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-62),
+				0x01, 0x00, 0x00, 0x00, // 1 (09),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-6E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-66),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-72),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-0F),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-10),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-11),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-12),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-13),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-14),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-15),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-16),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-17),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-18),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-19),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1A),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1B),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1C),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1D),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-1F),
+				0x01, 0x00, 0x00, 0x00, // 1 (20),
+				0x01, 0x00, 0x00, 0x00, // 1 (21),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-22),
+				0x01, 0x00, 0x00, 0x00, // 1 (23),
+				0x01, 0x00, 0x00, 0x00, // 1 (24),
+				0x01, 0x00, 0x00, 0x00, // 1 (25),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-26),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-27),
+				0x01, 0x00, 0x00, 0x00, // 1 (28),
+				0x01, 0x00, 0x00, 0x00, // 1 (29),
+				0x01, 0x00, 0x00, 0x00, // 1 (2A),
+				0x01, 0x00, 0x00, 0x00, // 1 (2B),
+				0x01, 0x00, 0x00, 0x00, // 1 (2C),
+				0x01, 0x00, 0x00, 0x00, // 1 (2D),
+				0x01, 0x00, 0x00, 0x00, // 1 (2E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-2F),
+				0x01, 0x00, 0x00, 0x00, // 1 (30),
+				0x01, 0x00, 0x00, 0x00, // 1 (31),
+				0x01, 0x00, 0x00, 0x00, // 1 (32),
+				0x01, 0x00, 0x00, 0x00, // 1 (33),
+				0x01, 0x00, 0x00, 0x00, // 1 (34),
+				0x01, 0x00, 0x00, 0x00, // 1 (35),
+				0x01, 0x00, 0x00, 0x00, // 1 (36),
+				0x01, 0x00, 0x00, 0x00, // 1 (37),
+				0x01, 0x00, 0x00, 0x00, // 1 (38),
+				0x01, 0x00, 0x00, 0x00, // 1 (39),
+				0x01, 0x00, 0x00, 0x00, // 1 (3A),
+				0x01, 0x00, 0x00, 0x00, // 1 (3B),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-3C),
+				0x01, 0x00, 0x00, 0x00, // 1 (3D),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-3E),
+				0x01, 0x00, 0x00, 0x00, // 1 (3F),
+				0x01, 0x00, 0x00, 0x00, // 1 (40),
+				0x01, 0x00, 0x00, 0x00, // 1 (41),
+				0x01, 0x00, 0x00, 0x00, // 1 (42),
+				0x01, 0x00, 0x00, 0x00, // 1 (43),
+				0x01, 0x00, 0x00, 0x00, // 1 (44),
+				0x01, 0x00, 0x00, 0x00, // 1 (45),
+				0x01, 0x00, 0x00, 0x00, // 1 (46),
+				0x01, 0x00, 0x00, 0x00, // 1 (47),
+				0x01, 0x00, 0x00, 0x00, // 1 (48),
+				0x01, 0x00, 0x00, 0x00, // 1 (49),
+				0x01, 0x00, 0x00, 0x00, // 1 (4A),
+				0x01, 0x00, 0x00, 0x00, // 1 (4B),
+				0x01, 0x00, 0x00, 0x00, // 1 (4C),
+				0x01, 0x00, 0x00, 0x00, // 1 (4D),
+				0x01, 0x00, 0x00, 0x00, // 1 (4E),
+				0x01, 0x00, 0x00, 0x00, // 1 (4F),
+				0x01, 0x00, 0x00, 0x00, // 1 (50),
+				0x01, 0x00, 0x00, 0x00, // 1 (51),
+				0x01, 0x00, 0x00, 0x00, // 1 (52),
+				0x01, 0x00, 0x00, 0x00, // 1 (53),
+				0x01, 0x00, 0x00, 0x00, // 1 (54),
+				0x01, 0x00, 0x00, 0x00, // 1 (55),
+				0x01, 0x00, 0x00, 0x00, // 1 (56),
+				0x01, 0x00, 0x00, 0x00, // 1 (57),
+				0x01, 0x00, 0x00, 0x00, // 1 (58),
+				0x01, 0x00, 0x00, 0x00, // 1 (59),
+				0x01, 0x00, 0x00, 0x00, // 1 (5A),
+				0x01, 0x00, 0x00, 0x00, // 1 (5B),
+				0x02, 0x00, 0x00, 0x00, // 2 (5C-5C),
+				0x01, 0x00, 0x00, 0x00, // 1 (5D),
+				0x01, 0x00, 0x00, 0x00, // 1 (5E),
+				0x01, 0x00, 0x00, 0x00, // 1 (5F),
+				0x01, 0x00, 0x00, 0x00, // 1 (60),
+				0x01, 0x00, 0x00, 0x00, // 1 (61),
+				0x01, 0x00, 0x00, 0x00, // 1 (62),
+				0x01, 0x00, 0x00, 0x00, // 1 (63),
+				0x01, 0x00, 0x00, 0x00, // 1 (64),
+				0x01, 0x00, 0x00, 0x00, // 1 (65),
+				0x01, 0x00, 0x00, 0x00, // 1 (66),
+				0x01, 0x00, 0x00, 0x00, // 1 (67),
+				0x01, 0x00, 0x00, 0x00, // 1 (68),
+				0x01, 0x00, 0x00, 0x00, // 1 (69),
+				0x01, 0x00, 0x00, 0x00, // 1 (6A),
+				0x01, 0x00, 0x00, 0x00, // 1 (6B),
+				0x01, 0x00, 0x00, 0x00, // 1 (6C),
+				0x01, 0x00, 0x00, 0x00, // 1 (6D),
+				0x01, 0x00, 0x00, 0x00, // 1 (6E),
+				0x01, 0x00, 0x00, 0x00, // 1 (6F),
+				0x01, 0x00, 0x00, 0x00, // 1 (70),
+				0x01, 0x00, 0x00, 0x00, // 1 (71),
+				0x01, 0x00, 0x00, 0x00, // 1 (72),
+				0x01, 0x00, 0x00, 0x00, // 1 (73),
+				0x01, 0x00, 0x00, 0x00, // 1 (74),
+				0x01, 0x00, 0x00, 0x00, // 1 (75),
+				0x01, 0x00, 0x00, 0x00, // 1 (76),
+				0x01, 0x00, 0x00, 0x00, // 1 (77),
+				0x01, 0x00, 0x00, 0x00, // 1 (78),
+				0x01, 0x00, 0x00, 0x00, // 1 (79),
+				0x01, 0x00, 0x00, 0x00, // 1 (7A),
+				0x01, 0x00, 0x00, 0x00, // 1 (7B),
+				0x01, 0x00, 0x00, 0x00, // 1 (7C),
+				0x01, 0x00, 0x00, 0x00, // 1 (7D),
+				0x01, 0x00, 0x00, 0x00, // 1 (7E),
+				0x06, 0x00, 0x00, 0x00, // 6 (5C-75-00-00-00-7F),
+			};
+	}
+}
+
diff --git a/src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.tt b/src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.tt
new file mode 100644
index 000000000..5ed0fc745
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonEscapeSequence.EscapeTables.tt
@@ -0,0 +1,218 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace MsgPack.Json
+{
+	partial class JsonEscapeSequence
+	{
+<#
+foreach (var spec in
+	new []
+	{
+		new { Label = "Base",							ExcludesTab = false,	ExcludesHtmlChars = true },
+		new { Label = "BaseWithoutTab",					ExcludesTab = true,		ExcludesHtmlChars = true },
+		new { Label = "BaseWithHtmlChars",				ExcludesTab = false,	ExcludesHtmlChars = false },
+		new { Label = "BaseWithHtmlCharsWithoutTab",	ExcludesTab = true,		ExcludesHtmlChars = false },
+	}
+)
+{
+#>
+
+		public static ReadOnlySpan<ulong> <#= spec.Label #>EscapeTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, ulong>(<#= spec.Label #>EscapeTableLittleEndian) :
+				MemoryMarshal.Cast<byte, ulong>(<#= spec.Label #>EscapeTableBigEndian);
+
+		public static ReadOnlySpan<int> <#= spec.Label #>EscapeLengthTable =>
+			BitConverter.IsLittleEndian ?
+				MemoryMarshal.Cast<byte, int>(<#= spec.Label #>EscapeLengthTableLittleEndian) :
+				MemoryMarshal.Cast<byte, int>(<#= spec.Label #>EscapeLengthTableBigEndian);
+
+		public static ReadOnlySpan<byte> <#= spec.Label #>EscapeTableBigEndian =>
+			new byte[]
+			{
+<#
+	for (var i = 0; i < 0x80; i++)
+	{
+#>
+				<#= Generate(i, spec.ExcludesTab, spec.ExcludesHtmlChars, forLittleEndian: false) #>,
+<#
+	}
+#>
+			};
+
+		public static ReadOnlySpan<byte> <#= spec.Label #>EscapeTableLittleEndian =>
+			new byte[]
+			{
+<#
+	for (var i = 0; i < 0x80; i++)
+	{
+#>
+				<#= Generate(i, spec.ExcludesTab, spec.ExcludesHtmlChars, forLittleEndian: true) #>,
+<#
+	}
+#>
+			};
+
+		public static ReadOnlySpan<byte> <#= spec.Label #>EscapeLengthTableBigEndian =>
+			new byte[]
+			{
+<#
+	for (var i = 0; i < 0x80; i++)
+	{
+#>
+				<#= GenerateLength(i, spec.ExcludesTab, spec.ExcludesHtmlChars, forLittleEndian: false) #>,
+<#
+	}
+#>
+			};
+
+		public static ReadOnlySpan<byte> <#= spec.Label #>EscapeLengthTableLittleEndian =>
+			new byte[]
+			{
+<#
+	for (var i = 0; i < 0x80; i++)
+	{
+#>
+				<#= GenerateLength(i, spec.ExcludesTab, spec.ExcludesHtmlChars, forLittleEndian: true) #>,
+<#
+	}
+#>
+			};
+<#
+}
+#>
+	}
+}
+
+<#+
+string Generate(int codePoint, bool excludesTab, bool excludesHtmlChars, bool forLittleEndian)
+{
+	var bytes = GetEscapeSequenceBytes(codePoint, excludesTab, excludesHtmlChars);
+	if (bytes.Length > 8)
+	{
+		throw new Exception($"U+{codePoint:X4} requires {bytes.Length} bytes.");
+	}
+
+	var span = new byte[8];
+	bytes.CopyTo(span, 0);
+
+	if (BitConverter.IsLittleEndian != forLittleEndian)
+	{
+		Array.Reverse(span);
+	}
+
+	var result = BitConverter.ToUInt64(span, 0);
+
+	return $"{String.Join(", ", span.Select(b => $"0x{b:X2}"))}, // 0x{result:X16}";
+}
+
+string GenerateLength(int codePoint, bool excludesTab, bool excludesHtmlChars, bool forLittleEndian)
+{
+	var bytes = GetEscapeSequenceBytes(codePoint, excludesTab, excludesHtmlChars);
+	var span = BitConverter.GetBytes(bytes.Length);
+
+	if (BitConverter.IsLittleEndian != forLittleEndian)
+	{
+		Array.Reverse(span);
+	}
+
+	return $"{String.Join(", ", span.Select(b => $"0x{b:X2}"))}, // {bytes.Length} ({BitConverter.ToString(bytes)})";
+}
+
+byte[] GetEscapeSequenceBytes(int codePoint, bool excludesTab, bool excludesHtmlChars)
+{
+	if (codePoint < 0x20)
+	{
+		switch (codePoint)
+		{
+			case '\b':
+			{
+				return new [] { (byte)'\\', (byte)'b' };
+			}
+			case '\f':
+			{
+				return new [] { (byte)'\\', (byte)'f' };
+			}
+			case '\r':
+			{
+				return new [] { (byte)'\\', (byte)'r' };
+			}
+			case '\n':
+			{
+				return new [] { (byte)'\\', (byte)'n' };
+			}
+			case '\t':
+			{
+				if (excludesTab)
+				{
+					break;
+				}
+
+				return new [] { (byte)'\\', (byte)'t' };
+			}
+			default:
+			{
+				return GetUnicodeEscapeEquence(codePoint);
+			}
+		}
+	}
+
+	if (codePoint == '\\')
+	{
+		return new [] { (byte)'\\', (byte)'\\' };
+	}
+
+	if (!excludesHtmlChars)
+	{
+		switch(codePoint)
+		{
+			case '"':
+			case '/':
+			case '&':
+			case '\'':
+			case '<':
+			case '>':
+			{
+				return GetUnicodeEscapeEquence(codePoint);
+			}
+		}
+	}
+
+	if (codePoint == '"')
+	{
+		return new [] { (byte)'\\', (byte)'"' };
+	}
+
+	if (codePoint == 0x7F)
+	{
+		return GetUnicodeEscapeEquence(codePoint);
+	}
+
+	return new [] { (byte)codePoint };
+}
+
+byte[] GetUnicodeEscapeEquence(int codePoint)
+{
+	var result = new byte[6];
+	result[0] = (byte)'\\';
+	result[1] = (byte)'u';
+	result[2] = (byte)(codePoint >> 24 & 0xFF);
+	result[3] = (byte)(codePoint >> 16 & 0xFF);
+	result[4] = (byte)(codePoint >> 8 & 0xFF);
+	result[5] = (byte)(codePoint & 0xFF);
+	return result;
+}
+#>
diff --git a/src/MsgPack.Json/Json/JsonEscapeSequence.cs b/src/MsgPack.Json/Json/JsonEscapeSequence.cs
index ef8af6318..9a4c8baf6 100644
--- a/src/MsgPack.Json/Json/JsonEscapeSequence.cs
+++ b/src/MsgPack.Json/Json/JsonEscapeSequence.cs
@@ -10,7 +10,7 @@ namespace MsgPack.Json
 	/// <summary>
 	///		Defines known escape sequence int UTF-8 and related structures.
 	/// </summary>
-	internal static class JsonEscapeSequence
+	internal static partial class JsonEscapeSequence
 	{
 		public static ReadOnlySpan<byte> Unicode => new[] { (byte)'\\', (byte)'u' };
 		public static ReadOnlySpan<byte> ReverseSolidous => new[] { (byte)'\\', (byte)'\\' };
diff --git a/src/MsgPack.Json/Json/JsonFormatter.cs b/src/MsgPack.Json/Json/JsonFormatter.cs
index 084622065..61e62689f 100644
--- a/src/MsgPack.Json/Json/JsonFormatter.cs
+++ b/src/MsgPack.Json/Json/JsonFormatter.cs
@@ -4,6 +4,8 @@
 
 using System.Buffers;
 using System.Buffers.Text;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
 
 namespace MsgPack.Json
 {
@@ -12,10 +14,19 @@ namespace MsgPack.Json
 	/// </summary>
 	internal static class JsonFormatter
 	{
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public static void WriteNull(IBufferWriter<byte> buffer)
-			=> buffer.Write(JsonTokens.Null);
+		{
+			var span = buffer.GetSpan(4);
+			span[0] = (byte)'n';
+			span[1] = (byte)'u';
+			span[2] = (byte)'l';
+			span[3] = (byte)'l';
+			buffer.Advance(4);
+		}
 
-		public static void Format(float value, IBufferWriter<byte> buffer, JsonEncoderOptions options)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static void Format(float value, IBufferWriter<byte> buffer)
 		{
 			var span = buffer.GetSpan(0);
 			while (!Utf8Formatter.TryFormat(value, span, out _))
@@ -24,7 +35,8 @@ public static void Format(float value, IBufferWriter<byte> buffer, JsonEncoderOp
 			}
 		}
 
-		public static void Format(double value, IBufferWriter<byte> buffer, JsonEncoderOptions options)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static void Format(double value, IBufferWriter<byte> buffer)
 		{
 			var span = buffer.GetSpan(0);
 			while (!Utf8Formatter.TryFormat(value, span, out _))
diff --git a/src/MsgPack.Json/Json/JsonNumberTokens.cs b/src/MsgPack.Json/Json/JsonNumberTokens.cs
deleted file mode 100644
index e8d9b1c00..000000000
--- a/src/MsgPack.Json/Json/JsonNumberTokens.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-
-namespace MsgPack.Json
-{
-	/// <summary>
-	///		Defines JSON number decoding related binary constants which are stored as native BLOB.
-	/// </summary>
-	internal static class JsonNumberTokens
-	{
-		public static readonly byte MinusSign = (byte)'-';
-		public static readonly byte PlusSign = (byte)'+';
-		public static readonly byte SingleByteUnicodeMinusSign = MinusSign;
-		public static readonly byte[][] MultiByteUnicodeMinusSigns =
-			new[]
-			{
-				new byte[] { 0xE2, 0x81, 0xBB }, // U+207B SUPERSCRIPT MINUS SIGN
-				new byte[] { 0xE2, 0x82, 0x8B }, // U+208B SUBSCRIPT MINUS SIGN
-				new byte[] { 0xE2, 0x88, 0x92 }, // U+2212 MINUS SIGN
-				new byte[] { 0xEF, 0xB9, 0xA3 }, // U+FE63 SMALL HYPHEN-MINUS
-				new byte[] { 0xEF, 0xBC, 0x8D }, // U+FF0D FULLWIDTH HYPHEN-MINUS
-			};
-		public static readonly byte SingleByteUnicodePlus = PlusSign;
-		public static readonly byte[][] MultiByteUnicodePlusSigns =
-			new[]
-			{
-				new byte[] { 0xE2, 0x81, 0xBA }, // U+207A SUPERSCRIPT PLUS SIGN
-				new byte[] { 0xE2, 0x82, 0x8A }, // U+208A SUBSCRIPT PLUS SIGN
-				new byte[] { 0xEF, 0xAC, 0xA9 }, // U+FB29 HEBREW LETTER ALTERNATIVE PLUS SIGN
-				new byte[] { 0xEF, 0xB9, 0xA2 }, // U+FE62 SMALL PLUS SIGN
-				new byte[] { 0xEF, 0xBC, 0x8B }, // U+FE0B FULLWIDTH PLUS SIGN
-			};
-		public static ReadOnlySpan<byte> Digits => new byte[] { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 };
-		public static ReadOnlySpan<byte> NonZeroDigits => new byte[] { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 };
-		public static ReadOnlySpan<byte> ExponentialIndicators => new[] { (byte)'E', (byte)'e' };
-		public static ReadOnlySpan<byte> PlusMinusSigns => new[] { (byte)'-', (byte)'+' };
-		public static readonly byte[][] MultiByteUnicodePlusMinusSigns =
-			new[]
-			{
-				new byte[] { 0xE2, 0x81, 0xBB }, // U+207B SUPERSCRIPT MINUS SIGN
-				new byte[] { 0xE2, 0x82, 0x8B }, // U+208B SUBSCRIPT MINUS SIGN
-				new byte[] { 0xE2, 0x88, 0x92 }, // U+2212 MINUS SIGN
-				new byte[] { 0xEF, 0xB9, 0xA3 }, // U+FE63 SMALL HYPHEN-MINUS
-				new byte[] { 0xEF, 0xBC, 0x8D },  // U+FF0D FULLWIDTH HYPHEN-MINUS
-				new byte[] { 0xE2, 0x81, 0xBA }, // U+207A SUPERSCRIPT PLUS SIGN
-				new byte[] { 0xE2, 0x82, 0x8A }, // U+208A SUBSCRIPT PLUS SIGN
-				new byte[] { 0xEF, 0xAC, 0xA9 }, // U+FB29 HEBREW LETTER ALTERNATIVE PLUS SIGN
-				new byte[] { 0xEF, 0xB9, 0xA2 }, // U+FE62 SMALL PLUS SIGN
-				new byte[] { 0xEF, 0xBC, 0x8B }, // U+FE0B FULLWIDTH PLUS SIGN
-			};
-		public static ReadOnlySpan<byte> SingleByteUnicodeExponentialIndicators => ExponentialIndicators;
-		public static readonly byte[][] MultiByteUnicodeExponentialIndicators =
-			new[]
-			{
-				new byte[] { 0xE1, 0xB4, 0xB1 }, // U+1D31 MODIFIER LETTER CAPITAL E
-				new byte[] { 0xE1, 0xB5, 0x89 }, // U+1D49 MODIFIER LETTER SMALL E
-				new byte[] { 0xE2, 0x82, 0x91 }, // U+2091 LATIN SUBSCRIPT SMALL LETTER E
-				new byte[] { 0xE2, 0x84, 0xAF }, // U+212F SCRIPT SMALL E
-				new byte[] { 0xE2, 0x84, 0xB0 }, // U+2130 SCRIPT CAPITAL E
-				new byte[] { 0xE2, 0x85, 0x87 }, // U+2147 DOUBLE-STRUCK ITALIC SMALL E
-				new byte[] { 0xE2, 0x92, 0xBA }, // U+24BA CIRCLED LATIN CAPITAL LETTER E
-				new byte[] { 0xE2, 0x93, 0x94 }, // U+24D4 CIRCLED LATIN SMALL LETTER E
-				new byte[] { 0xEF, 0xBC, 0xA5 }, // U+FF25 FULLWIDTH LATIN CAPITAL LETTER E
-				new byte[] { 0xEF, 0xBD, 0x85 }, // U+FF45 FULLWIDTH LATIN SMALL LETTER E
-				new byte[] { 0xF0, 0x9D, 0x90, 0x84 }, // U+1D404 MATHEMATICAL BOLD CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x90, 0x9E }, // U+1D41E ATHEMATICAL BOLD SMALL E
-				new byte[] { 0xF0, 0x9D, 0x90, 0xB8 }, // U+1D438 MATHEMATICAL ITALIC CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x91, 0x92 }, // U+1D452 MATHEMATICAL ITALIC SMALL E
-				new byte[] { 0xF0, 0x9D, 0x91, 0xAC }, // U+1D46C MATHEMATICAL BOLD ITALIC CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x92, 0x86 }, // U+1D486 MATHEMATICAL BOLD ITALIC SMALL E
-				new byte[] { 0xF0, 0x9D, 0x93, 0x94 }, // U+1D4D4 MATHEMATICAL BOLD SCRIPT CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x93, 0xAE }, // U+1D4EE MATHEMATICAL BOLD SCRIPT SMALL E
-				new byte[] { 0xF0, 0x9D, 0x94, 0x88 }, // U+1D508 MATHEMATICAL FRAKTUR CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x94, 0xA2 }, // U+1D522 MATHEMATICAL FRAKTUR SMALL E
-				new byte[] { 0xF0, 0x9D, 0x94, 0xBC }, // U+1D53C MATHEMATICAL DOUBLE-STRUCK CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x95, 0x96 }, // U+1D556 MATHEMATICAL DOUBLE-STRUCK SMALL E
-				new byte[] { 0xF0, 0x9D, 0x95, 0xB0 }, // U+1D570 MATHEMATICAL BOLD FRAKTUR CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x96, 0x8A }, // U+1D58A MATHEMATICAL BOLD FRAKTUR SMALL E
-				new byte[] { 0xF0, 0x9D, 0x96, 0xA4 }, // U+1D5A4 MATHEMATICAL SANS-SERIF CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x96, 0xBE }, // U+1D5BE MATHEMATICAL SANS-SERIF SMALL E
-				new byte[] { 0xF0, 0x9D, 0x97, 0x98 }, // U+1D5D8 MATHEMATICAL SANS-SERIF BOLD CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x97, 0xB2 }, // U+1D5F2 MATHEMATICAL SANS-SERIF BOLD SMALL E
-				new byte[] { 0xF0, 0x9D, 0x98, 0x8C }, // U+1D60C MATHEMATICAL SANS-SERIF ITALIC CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x98, 0xA6 }, // U+1D626 MATHEMATICAL SANS-SERIF ITALIC SMALL E
-				new byte[] { 0xF0, 0x9D, 0x99, 0x80 }, // U+1D640 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x99, 0x9A }, // U+1D65A MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL E
-				new byte[] { 0xF0, 0x9D, 0x99, 0xB4 }, // U+1D674 MATHEMATICAL MONOSPACE CAPITAL E
-				new byte[] { 0xF0, 0x9D, 0x9A, 0x8E }, // U+1D68E MATHEMATICAL MONOSPACE SMALL E
-				new byte[] { 0xF0, 0x9F, 0x84, 0xB4 }, // U+1F134 SQUARED LATIN CAPITAL LETTER E
-			};
-	}
-}
diff --git a/src/MsgPack.Json/Json/JsonStringTokens.cs b/src/MsgPack.Json/Json/JsonStringTokens.cs
index 89334c75b..c3a353633 100644
--- a/src/MsgPack.Json/Json/JsonStringTokens.cs
+++ b/src/MsgPack.Json/Json/JsonStringTokens.cs
@@ -13,31 +13,5 @@ internal static class JsonStringTokens
 	{
 		public static ReadOnlySpan<byte> AnyQuotations => new[] { (byte)'"', (byte)'\'' };
 		public static ReadOnlySpan<byte> DoubleQuotation => AnyQuotations.Slice(0, 1);
-		public static ReadOnlySpan<byte> SingleQuotationDelimiters => new[] { (byte)'\'', (byte)'\\' };
-		public static ReadOnlySpan<byte> DoubleQuotationDelimiters => new[] { (byte)'"', (byte)'\\' };
-		public static readonly byte UnescapedCharactorsOffset = UnescapedCharactors[0];
-		public static ReadOnlySpan<byte> UnescapedCharactors =>
-			new byte[]
-			{
-				(byte)'"', // U+0022 "
-				0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, // U+0023-U+002E
-				(byte)'/', // U+002F /
-				0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, // U+0030-U+003F
-				0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, // U+0040-U+004F
-				0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, // U+0050-U+005B
-				(byte)'\\', // U+005C \
-				0xBD, 0xBE, 0xBF, // U+005D-U+005F
-				0xC0, 0xC1, // U+0060-U+0061
-				(byte)'\b', // U+0062 -> U+0008 Back Space
-				0xC3, 0xC4, 0xC5, // U+0063-U+0065
-				(byte)'\f', // U+0066 -> U+000C Form Feed
-				0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, // UL0067-U+006D
-				(byte)'\n', // U+006E -> U+000A Line Feed
-				0xCF, // U+006F
-				0xD0, 0xD1, // U+0070-U+0071
-				(byte)'\r', // U+0072 -> U+000D Carriage Return  
-				0xD3, // U+0073
-				(byte)'\t', // U+0074 -> U+0009 Tab
-			};
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonThrow.cs b/src/MsgPack.Json/Json/JsonThrow.cs
index aa6f09536..f26a1053f 100644
--- a/src/MsgPack.Json/Json/JsonThrow.cs
+++ b/src/MsgPack.Json/Json/JsonThrow.cs
@@ -35,7 +35,7 @@ public static void SurrogateCharInUtf8(long position, int codePoint)
 			=> throw new FormatException($"Input UTF-8 has surrogate charactor U+{codePoint:X4} at position {position:#,0}.");
 
 		public static void IsNotArrayNorObject(in ReadOnlySequence<byte> sequence, long position)
-			=> throw new FormatException($"Char '{Stringify(sequence)}' at position {position:#,0} is not start of array nor object.");
+			=> throw new FormatException($"Char {Stringify(sequence)} at position {position:#,0} is not start of array nor object.");
 
 		public static void IsNotArray(long position)
 			=> throw new FormatException($"Char '{{' at position {position:#,0} is not start of array.");
@@ -44,7 +44,7 @@ public static void IsNotObject(long position)
 			=> throw new FormatException($"Char '[' at position {position:#,0} is not start of object.");
 
 		public static void IsNotType(Type type, in ReadOnlySequence<byte> unit, long position)
-			=> throw new FormatException($"Char '{Stringify(unit)}' at position {position:#,0} is not valid for {type} value.");
+			=> throw new FormatException($"Char {Stringify(unit)} at position {position:#,0} is not valid for {type} value.");
 
 		public static void TooLongNumber(long numberLength, long maxLength, long position)
 			=> throw new FormatException($"The number at position {position:#,0} has {numberLength:#,0} charactors, but maximum allowed length is {maxLength:#,0}.");
diff --git a/src/MsgPack.Json/Json/JsonTokens.cs b/src/MsgPack.Json/Json/JsonTokens.cs
deleted file mode 100644
index 0ac1260dd..000000000
--- a/src/MsgPack.Json/Json/JsonTokens.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-
-namespace MsgPack.Json
-{
-	/// <summary>
-	///		Defines JSON tokens as UTF-8 byte blob data.
-	/// </summary>
-	internal static class JsonTokens
-	{
-		// Utilizes C# optimization to read data directly from blob metadata without array allocation.
-		public static ReadOnlySpan<byte> Null => new[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
-		public static ReadOnlySpan<byte> True => new[] { (byte)'t', (byte)'r', (byte)'u', (byte)'e' };
-		public static ReadOnlySpan<byte> False => new[] { (byte)'f', (byte)'a', (byte)'l', (byte)'s', (byte)'e' };
-		public static ReadOnlySpan<byte> ArrayStart => new[] { (byte)'[' };
-		public static ReadOnlySpan<byte> ArrayEnd => new[] { (byte)']' };
-		public static ReadOnlySpan<byte> MapStart => new[] { (byte)'{' };
-		public static ReadOnlySpan<byte> MapEnd => new[] { (byte)'}' };
-		public static ReadOnlySpan<byte> Whitespace => new[] { (byte)' ' };
-		public static ReadOnlySpan<byte> Comma => new[] { (byte)',' };
-		public static ReadOnlySpan<byte> Colon => new[] { (byte)':' };
-		public static ReadOnlySpan<byte> Quatation => new[] { (byte)'"' };
-
-		public static ReadOnlySpan<byte> Undefined => new[] { (byte)'u', (byte)'n', (byte)'d', (byte)'e', (byte)'f', (byte)'i', (byte)'n', (byte)'e', (byte)'d' };
-	}
-}
diff --git a/src/MsgPack.Json/Json/JsonTriviaTokens.cs b/src/MsgPack.Json/Json/JsonTriviaTokens.cs
index 89a3552f1..c2bc1b2b4 100644
--- a/src/MsgPack.Json/Json/JsonTriviaTokens.cs
+++ b/src/MsgPack.Json/Json/JsonTriviaTokens.cs
@@ -2,8 +2,6 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
-using System;
-
 namespace MsgPack.Json
 {
 	/// <summary>
@@ -11,13 +9,6 @@ namespace MsgPack.Json
 	/// </summary>
 	internal static class JsonTriviaTokens
 	{
-		public static ReadOnlySpan<byte> StandardWhitespaces => new[] { (byte)' ', (byte)'\t', (byte)'\r', (byte)'\n' };
-		public static ReadOnlySpan<byte> NewLine => new[] { (byte)'\r', (byte)'\n' };
-		public static ReadOnlySpan<byte> SingleByteUnicodeWhitespaces =>
-			new[] {
-				(byte)' ', (byte)'\t', (byte)'\r', (byte)'\n',
-				(byte)'\u000B',(byte)'\u000C'
-			};
 		public static readonly byte[][] MultiByteUnicodeWhitespaces =
 			new[]
 			{
@@ -41,8 +32,5 @@ internal static class JsonTriviaTokens
 				new byte[] { 0xE2, 0x81, 0x9F }, // U+205F MEDIUM MATHEMATICAL SPACE
 				new byte[] { 0xEe, 0x80, 0x80 }, // U+3000 IDEOGRAPHIC SPACE
 			};
-		public static ReadOnlySpan<byte> SingleLineCommentStart2 => new byte[] { (byte)'/', (byte)'/' };
-		public static ReadOnlySpan<byte> MultiLineCommentStart => new byte[] { (byte)'/', (byte)'*' };
-		public static ReadOnlySpan<byte> MultiLineCommentEnd => new byte[] { (byte)'*', (byte)'/' };
 	}
 }
diff --git a/src/MsgPack.Json/Json/SimpleJsonDecoder.cs b/src/MsgPack.Json/Json/SimpleJsonDecoder.cs
index 9fd56f598..a5373ef1c 100644
--- a/src/MsgPack.Json/Json/SimpleJsonDecoder.cs
+++ b/src/MsgPack.Json/Json/SimpleJsonDecoder.cs
@@ -2,7 +2,10 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using System;
 using System.Buffers;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
 
 namespace MsgPack.Json
 {
@@ -14,14 +17,25 @@ internal sealed class SimpleJsonDecoder : JsonDecoder
 		public SimpleJsonDecoder(JsonDecoderOptions options)
 			: base(options) { }
 
-		protected override void ReadTrivia(in SequenceReader<byte> source, out ReadOnlySequence<byte> trivia)
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		protected sealed override long ReadTrivia(ref SequenceReader<byte> source)
+			=> source.AdvancePastAny((byte)' ', (byte)'\t', (byte)'\r', (byte)'\n');
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public sealed override unsafe bool TryDecodeNull(ref SequenceReader<byte> source, out int requestHint)
 		{
-			var offset = source.Consumed;
-			var consumed = source.AdvancePastAny(JsonTriviaTokens.StandardWhitespaces);
-			trivia = source.Sequence.Slice(offset, consumed);
-		}
+			byte* pNull = stackalloc byte[] { (byte)'n', (byte)'u', (byte)'l', (byte)'l' };
+			ReadOnlySpan<byte> @null = new ReadOnlySpan<byte>(pNull, 4);
 
-		protected override bool TryReadNull(in SequenceReader<byte> source)
-			=> source.IsNext(JsonTokens.Null, advancePast: true);
+			if (source.IsNext(@null, advancePast: true))
+			{
+				requestHint = 0;
+				source.Advance(4);
+				return true;
+			}
+
+			requestHint = Math.Max(0, 4 - (int)source.Remaining);
+			return false;
+		}
 	}
 }
diff --git a/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs b/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs
index 649d095ae..3d6330da9 100644
--- a/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs
+++ b/src/MsgPack.Json/Json/StringBuilderBufferWriter.cs
@@ -33,7 +33,8 @@ public StringBuilderBufferWriter(StringBuilder stringBuilder, JsonDecoderOptions
 			this._stringBuilder = stringBuilder;
 			this._bufferPool = options.CharBufferPool;
 			this._clearsArray = options.ClearsBuffer;
-			this._buffer = this._bufferPool.Rent(options.MaxCharBufferLength);
+#warning TODO: OPTION
+			this._buffer = this._bufferPool.Rent(64/*options.MaxCharBufferLength*/);
 		}
 
 		public void Dispose()
diff --git a/src/MsgPack.Json/MsgPack.Json.csproj b/src/MsgPack.Json/MsgPack.Json.csproj
index d3a1baa67..d7dfa0faa 100644
--- a/src/MsgPack.Json/MsgPack.Json.csproj
+++ b/src/MsgPack.Json/MsgPack.Json.csproj
@@ -12,10 +12,15 @@
   <ItemGroup>
     <Compile Include="../MsgPack.Core/Internal/MemoryExtensions.cs" Link="Internal/MemoryExtensions.cs" />
     <Compile Include="../MsgPack.Core/System.Text/EncodingExtensions.cs" Link="System.Text/EncodingExtensions.cs" />
+    <Compile Include="..\MsgPack.Core\System.Text\Throw.cs" Link="System.Text\Throw.cs" />
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="System.Text/" />
+    <None Include="Json\JsonEscapeSequence.EscapeTables.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>JsonEscapeSequence.EscapeTables.tt</DependentUpon>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -27,6 +32,10 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>JsonDecoder.Numbers.cs</LastGenOutput>
     </None>
+    <None Update="Json\JsonEscapeSequence.EscapeTables.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>JsonEscapeSequence.EscapeTables.cs</LastGenOutput>
+    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -44,6 +53,15 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>JsonDecoder.Numbers.tt</DependentUpon>
     </Compile>
+    <Compile Update="Json\JsonEscapeSequence.EscapeTables.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>JsonEscapeSequence.EscapeTables.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="System.Text\" />
   </ItemGroup>
 
 </Project>

From 2aa85e12e9c67173fe394cfcd8f8988741622ce6 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 21 Jun 2020 01:20:25 +0900
Subject: [PATCH 25/82] Add v2 benchmarks

Note that they uses hand-made serializer yet because the purpose is PoC of new serializer primitives design.
---
 src/MsgPack.Core/_SampleObject.cs             | 1195 ----------
 .../Serializers/MsgPackCliSerializer.cs       |  133 ++
 test/Benchmark/Program.cs                     |  172 ++
 test/Benchmark/_SampleObject.cs               | 2003 +++++++++++++++++
 4 files changed, 2308 insertions(+), 1195 deletions(-)
 delete mode 100644 src/MsgPack.Core/_SampleObject.cs
 create mode 100644 test/Benchmark/Program.cs
 create mode 100644 test/Benchmark/_SampleObject.cs

diff --git a/src/MsgPack.Core/_SampleObject.cs b/src/MsgPack.Core/_SampleObject.cs
deleted file mode 100644
index ec77520f9..000000000
--- a/src/MsgPack.Core/_SampleObject.cs
+++ /dev/null
@@ -1,1195 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-using System.Buffers;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Threading.Tasks;
-using MsgPack.Internal;
-using MsgPack.Serialization.Internal;
-
-namespace MsgPack.Samples
-{
-	public class SampleObject
-	{
-		public int Age { get; set; }
-		public string Name { get; set; } = null!;
-		public bool IsActive { get; set; }
-		public IDictionary<string, string> Attributes { get; } = new Dictionary<string, string>();
-		public IList<string> Roles { get; } = new List<string>();
-	}
-
-	// MP.Core.Abstraction
-	// MP.Core / MP.Json.Core / MP.Yaml.Core / MP.Coff.Core
-	// MP.Serialization.Core -> Interfaces, ....
-	// MP.Serialization -> Basic serializers, context, utilities, Stream adapter, byte[] adapter, etc.
-	// MP.Serialization.Serializers-> Extended serializers implementation.
-	// MP.Serialization.Reflection -> Reflection
-	// MP.Serialization.ILGeneration -> Reflection
-	// MP.Serialization.SourceGeneration -> Reflection
-	// MP.Extensions  / MP.Json.Extensions / MP.Yaml.Extensions / MP.Coff.Extensions -> MPO, DOM, etc
-	// MP.Compatibility1 -> v1 compatibility shims
-	// MP.Cli -> v1 compatibility shims
-
-	// Packer/Unpacker compatibility note:
-	// Packer -> Packer.Create(new MemoryStream())
-	// Unpacker -> Unpacker.Create(new MemoryStream())???
-
-	// For PoC of MVP and reference for emit.
-	/// <summary>
-	///		Sample hand made serializer.
-	/// </summary>
-	public sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleObject, TExtensionType>
-	{
-		private bool UseArray { get; set; }
-
-		public void Serialize(in SerializationOperationContext<TExtensionType> context, SampleObject obj, IBufferWriter<byte> writer)
-		{
-			var encoder = context.Encoder;
-			if (obj == null)
-			{
-				encoder.EncodeNull(writer);
-				return;
-			}
-
-			if (this.UseArray)
-			{
-				encoder.EncodeArrayStart(5, writer, context.CollectionContext); // OMITTABLE
-				encoder.EncodeString(obj.Name, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-				encoder.EncodeInt32(obj.Age, writer);
-				encoder.EncodeBoolean(obj.IsActive, writer);
-				if (obj.Attributes == null)
-				{
-					encoder.EncodeNull(writer);
-				}
-				else
-				{
-					encoder.EncodeMapStart(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
-					var i = 0; // OMITTABLE
-					foreach (var entry in obj.Attributes)
-					{
-						encoder.EncodeMapKeyStart(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeString(entry.Key, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-						encoder.EncodeMapKeyEnd(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeMapValueStart(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeString(entry.Value, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-						encoder.EncodeMapValueEnd(i, writer, context.CollectionContext); // OMITTABLE
-					}
-					encoder.EncodeMapEnd(obj.Attributes.Count, writer, context.CollectionContext);
-				}
-				if (obj.Roles == null)
-				{
-					encoder.EncodeNull(writer);
-				}
-				else
-				{
-					encoder.EncodeArrayStart(obj.Roles.Count, writer, context.CollectionContext); // OMITTABLE
-					var i = 0; // OMITTABLE
-					foreach (var item in obj.Roles)
-					{
-						encoder.EncodeArrayItemStart(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeString(item, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-						encoder.EncodeArrayItemEnd(i, writer, context.CollectionContext); // OMITTABLE
-					}
-					encoder.EncodeArrayEnd(obj.Roles.Count, writer, context.CollectionContext);
-				}
-				encoder.EncodeArrayEnd(5, writer, context.CollectionContext); // OMITTABLE
-			}
-			else
-			{
-				encoder.EncodeMapStart(5, writer, context.CollectionContext); // OMITTABLE
-				ReadOnlySpan<byte> key0 = new[] { (byte)'N', (byte)'a', (byte)'m', (byte)'e' }; // static readonly
-				encoder.EncodeString(key0, 4, writer, context.CancellationToken);
-				encoder.EncodeString(obj.Name, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-				ReadOnlySpan<byte> key1 = new[] { (byte)'A', (byte)'g', (byte)'e' }; // static readonly
-				encoder.EncodeString(key1, 3, writer, context.CancellationToken);
-				encoder.EncodeInt32(obj.Age, writer);
-				ReadOnlySpan<byte> key2 = new[] { (byte)'I', (byte)'s', (byte)'a', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e' }; // static readonly
-				encoder.EncodeString(key2, 8, writer, context.CancellationToken);
-				encoder.EncodeBoolean(obj.IsActive, writer);
-				ReadOnlySpan<byte> key3 = new[] { (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s' }; // static readonly
-				encoder.EncodeString(key3, 10, writer, context.CancellationToken);
-				if (obj.Attributes == null)
-				{
-					encoder.EncodeNull(writer);
-				}
-				else
-				{
-					encoder.EncodeMapStart(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
-					var i = 0; // OMITTABLE
-					foreach (var entry in obj.Attributes)
-					{
-						encoder.EncodeMapKeyStart(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeString(entry.Key, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-						encoder.EncodeMapKeyEnd(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeMapValueStart(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeString(entry.Value, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-						encoder.EncodeMapValueEnd(i, writer, context.CollectionContext); // OMITTABLE
-					}
-					encoder.EncodeMapEnd(obj.Attributes.Count, writer, context.CollectionContext);
-				}
-				ReadOnlySpan<byte> key4 = new[] { (byte)'R', (byte)'o', (byte)'l', (byte)'e' }; // static readonly
-				encoder.EncodeString(key4, 4, writer, context.CancellationToken);
-				if (obj.Roles == null)
-				{
-					encoder.EncodeNull(writer);
-				}
-				else
-				{
-					encoder.EncodeArrayStart(obj.Roles.Count, writer, context.CollectionContext); // OMITTABLE
-					var i = 0; // OMITTABLE
-					foreach (var item in obj.Roles)
-					{
-						encoder.EncodeArrayItemStart(i, writer, context.CollectionContext); // OMITTABLE
-						encoder.EncodeString(item, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-						encoder.EncodeArrayItemEnd(i, writer, context.CollectionContext); // OMITTABLE
-					}
-					encoder.EncodeArrayEnd(obj.Roles.Count, writer, context.CollectionContext);
-				}
-				encoder.EncodeMapEnd(5, writer, context.CollectionContext); // OMITTABLE
-			}
-		}
-
-		public async ValueTask SerializeAsync(SerializationOperationContext<TExtensionType> context, SampleObject obj, Stream streamSink)
-		{
-			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
-			{
-				this.Serialize(context, obj, writer);
-			}
-		}
-
-		private static readonly MsgPackStringTrie<uint> DeserializationTrie = InitializeDeserializationTrie();
-		private static MsgPackStringTrie<uint> InitializeDeserializationTrie()
-		{
-			ReadOnlySpan<byte> __name = new byte[] { 0xA4, (byte)'N', (byte)'a', (byte)'m', (byte)'e' };
-			ReadOnlySpan<byte> __age = new byte[] { 0xA3, (byte)'A', (byte)'g', (byte)'e' };
-			ReadOnlySpan<byte> __isActive = new byte[] { 0xAA, (byte)'i', (byte)'s', (byte)'A', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e' };
-			ReadOnlySpan<byte> __roles = new byte[] { 0xA4, (byte)'N', (byte)'a', (byte)'m', (byte)'e', };
-			ReadOnlySpan<byte> __attributes = new byte[] { 0xAC, (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s' };
-			var trie = new MsgPackStringTrie<uint>(5);
-			trie.TryAdd(__name, 0);
-			trie.TryAdd(__age, 1);
-			trie.TryAdd(__isActive, 2);
-			trie.TryAdd(__roles, 3);
-			trie.TryAdd(__attributes, 4);
-			return trie;
-		}
-
-		public SampleObject Deserialize(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> reader)
-		{
-			// T が参照型でデフォルトコンストラクターがある -> DeserializeTo
-			var obj = new SampleObject();
-			this.DeserializeTo(context, reader, obj);
-			return obj;
-
-			// T にデフォルトコンストラクターがない -> from DeserializeTo と同じ処理をインライン実装
-			// ....
-			// return new SampleObject(name, age, isActive, roles, attributes);
-
-			// T がミュータブルな値型
-			// ...
-			// var obj = default;
-			// obj.Name = name;
-			// obj.Age = age;
-			// obj.IsActive = isActive;
-			// obj.Roles = roles; // Roles は絶対に null のはず。
-			// obj.Attributes = attributes; // Attributes は絶対に null のはず。
-			// return obj;
-		}
-
-		public async ValueTask<SampleObject> DeserializeAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource)
-		{
-			// T が参照型でデフォルトコンストラクターがある -> DeserializeToAsync
-			var obj = new SampleObject();
-			await this.DeserializeToAsync(context, streamSource, obj).ConfigureAwait(false);
-			return obj;
-
-			// T にデフォルトコンストラクターがない -> DeserializeToAsync と同じ処理をインライン実装
-			// ....
-			// return new SampleObject(name, age, isActive, roles, attributes);
-
-			// T がミュータブルな値型
-			// ...
-			// var obj = default;
-			// obj.Name = name;
-			// obj.Age = age;
-			// obj.IsActive = isActive;
-			// obj.Roles = roles; // Roles は絶対に null のはず。
-			// obj.Attributes = attributes; // Attributes は絶対に null のはず。
-			// return obj;
-		}
-
-		public void DeserializeTo(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> reader, in SampleObject obj)
-		{
-			string name = default!;
-			int age = default;
-			bool isActive = default;
-			var roles = obj.Roles;
-			var attributes = obj.Attributes;
-
-			var decoder = context.Decoder;
-			CollectionType arrayOrMap;
-			long itemsCount;
-			CollectionItemIterator propertyIterator;
-
-			if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-			{
-				arrayOrMap = decoder.DecodeArrayOrMapHeader(reader, out itemsCount);
-				if (itemsCount < 5)
-				{
-					throw new MessageTypeException(); // Use Throws
-				}
-
-				propertyIterator = default;
-			}
-			else
-			{
-				arrayOrMap = decoder.DecodeArrayOrMap(reader, out propertyIterator);
-				itemsCount = -1;
-			}
-
-			context.IncrementDepth();
-
-			// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
-			if (arrayOrMap.IsArray)
-			{
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					CheckNextItemExists(reader, ref propertyIterator);
-				}
-
-				name = decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					CheckNextItemExists(reader, ref propertyIterator);
-				}
-
-				age = decoder.DecodeInt32(reader);
-
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					CheckNextItemExists(reader, ref propertyIterator);
-				}
-
-				isActive = decoder.DecodeBoolean(reader);
-
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					CheckNextItemExists(reader, ref propertyIterator);
-				}
-
-				context.IncrementDepth();
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					var arrayLength = decoder.DecodeArrayHeader(reader);
-					// If settable
-					//if (roles == null)
-					//{
-					//	roles = new List<string>(arrayLength); // or 0
-					//}
-
-					for (var i = 0; i < arrayLength; i++)
-					{
-						roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
-					}
-				}
-				else
-				{
-					var iterator = decoder.DecodeArray(reader);
-					while (!iterator.CollectionEnds(reader))
-					{
-						roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
-					}
-					iterator.Drain(reader); 
-				}
-				context.DecrementDepth();
-
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					CheckNextItemExists(reader, ref propertyIterator);
-				}
-
-				context.IncrementDepth();
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					var mapCount = decoder.DecodeMapHeader(reader);
-					// If settable
-					//if (attributes == null)
-					//{
-					//	attributes = new Dictionary<string, string>(mapCount); // or 0
-					//}
-					for (var i = 0; i < mapCount; i++)
-					{
-						attributes.Add(
-							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
-							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
-						);
-					}
-				}
-				else
-				{
-					var iterator = decoder.DecodeMap(reader);
-					while (!iterator.CollectionEnds(reader))
-					{
-						attributes.Add(
-							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
-							decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
-						);
-					}
-					iterator.Drain(reader);
-				}
-				context.DecrementDepth();
-			}
-			else
-			{
-				// Map
-
-				// if !decoder.FormatFeatures.CanCountCollectionItems // OPTIMIZABLE
-				// while(!propertyIterator.CollectionEnds(reader))
-				for (var i = 0; i < itemsCount; i++)
-				{
-					decoder.GetRawString(reader, out ReadOnlySpan<byte> key, context.CancellationToken);
-
-					context.ValidatePropertyKeyLength(reader.Consumed, key.Length);
-
-					// Use inlined trie, prefixed by the count as MP uint32.
-					// char is UTF-8, big endian.
-					// 1st node: [length(1-5)][chars(7-3)]
-					switch (DeserializationTrie.GetOrDefault(key))
-					{
-						case 0:
-						{
-							name = decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
-							break;
-						}
-						case 1:
-						{
-							age = decoder.DecodeInt32(reader);
-							break;
-						}
-						case 2:
-						{
-							isActive = decoder.DecodeBoolean(reader);
-							break;
-						}
-						case 3:
-						{
-							context.IncrementDepth();
-							if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-							{
-								var arrayLength = decoder.DecodeArrayHeader(reader);
-								// If settable
-								//if (roles == null)
-								//{
-								//	roles = new List<string>(arrayLength); // or 0
-								//}
-								for (var j = 0; j < arrayLength; j++)
-								{
-									roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
-								}
-							}
-							else
-							{
-								var iterator = decoder.DecodeArray(reader);
-								while (!iterator.CollectionEnds(reader))
-								{
-									roles.Add(decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
-								}
-								iterator.Drain(reader);
-							}
-							context.DecrementDepth();
-							break;
-						}
-						case 4:
-						{
-							context.IncrementDepth();
-							if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-							{
-								var mapCount = decoder.DecodeMapHeader(reader);
-								// If settable
-								//if (attributes == null)
-								//{
-								//	attributes = new Dictionary<string, string>(mapCount); // or 0
-								//}
-								for (var j = 0; j < mapCount; j++)
-								{
-									attributes.Add(
-										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
-										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
-									);
-								}
-							}
-							else
-							{
-								var iterator = decoder.DecodeMap(reader);
-								while (!iterator.CollectionEnds(reader))
-								{
-									attributes.Add(
-										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
-										decoder.DecodeString(reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
-									);
-								}
-								iterator.Drain(reader);
-							}
-							context.DecrementDepth();
-							break;
-						}
-					}
-				}
-			}
-
-			if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-			{
-				decoder.Drain(reader, context.CollectionContext, itemsCount - 5, context.CancellationToken);
-			}
-			else
-			{
-				propertyIterator.Drain(reader);
-			}
-
-			context.DecrementDepth();
-
-			obj.Name = name;
-			obj.Age = age;
-			obj.IsActive = isActive;
-			// If settable
-			// obj.Roles = roles;
-			// If settable
-			// obj.Attributes = attributes;
-		}
-
-		private static void CheckNextItemExists(SequenceReader<byte> reader, ref CollectionItemIterator propertyIterator)
-		{
-			if (!propertyIterator.CollectionEnds(reader))
-			{
-				throw new MessageTypeException(); // Use Throws
-			}
-		}
-
-		private static bool TryDecodeArrayOrMapHeader(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
-		{
-			context.IncrementDepth();
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(reader, out itemsCount, out requestHint);
-			if (arrayOrMap.IsNone)
-			{
-				propertyIterator = default;
-				return false;
-			}
-
-			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-			{
-				arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(reader, out itemsCount);
-				if (itemsCount < 5)
-				{
-					throw new MessageTypeException(); // Use Throws
-				}
-
-				propertyIterator = default;
-			}
-			else
-			{
-				arrayOrMap = context.Decoder.DecodeArrayOrMap(reader, out propertyIterator);
-				itemsCount = -1;
-			}
-
-			memory = memory.Slice(unchecked((int)reader.Consumed));
-
-			return true;
-		}
-
-		private static bool TryDecodeArrayHeader(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long arrayLength, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			arrayLength = context.Decoder.DecodeArrayHeader(reader, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeMapHeader(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long mapCount, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			mapCount = context.Decoder.DecodeMapHeader(reader, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeValueOfName(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string name, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			name = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeValueOfAge(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out int age, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			age = context.Decoder.DecodeInt32(reader, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeValueOfIsActive(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out bool isActive, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			isActive = context.Decoder.DecodeBoolean(reader, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeItemOfRoles(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string item, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			item = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeKeyOfAttributes(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string key, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			key = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeValueOfAttributes(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string value, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			value = context.Decoder.DecodeString(reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeArray(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			iterator = context.Decoder.DecodeArray(reader, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryDecodeMap(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			iterator = context.Decoder.DecodeMap(reader, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private static bool TryGetRawString(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, [NotNullWhen(true)]out byte[] key, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-
-			ReadOnlySpan<byte> span;
-			if (!context.Decoder.GetRawString(reader, out span, out requestHint, context.CancellationToken))
-			{
-				key = default!;
-				return false;
-			}
-
-			key = context.ArrayPool.Rent(span.Length);
-			span.CopyTo(key);
-			return true;
-		}
-
-		private static bool TryDrain(in DeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, long remaining, out int requestHint)
-		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
-			context.Decoder.Drain(reader, context.CollectionContext, remaining, out requestHint);
-			if (requestHint == 0)
-			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
-			}
-			return requestHint == 0;
-		}
-
-		private bool TryCheckNextItemExists(ref CollectionItemIterator propertyIterator, ReadOnlyMemory<byte> memory, out int requestHint)
-		{
-			if (propertyIterator.CollectionEnds(memory, out requestHint))
-			{
-				throw new MessageTypeException(); // use throws
-			}
-
-			return requestHint == 0;
-		}
-
-		public async ValueTask DeserializeToAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource, SampleObject obj)
-		{
-			// T が値型
-			// throw new NotSupportedException();
-
-			var buffer = context.ArrayPool.Rent(2 * 1024 * 1024);
-			try
-			{
-				var provider = new StreamReadOnlyMemoryProvider(streamSource, buffer);
-				var memory = await provider.GetNextAsync(default, 0, context.CancellationToken).ConfigureAwait(false);
-				int requestHint;
-
-				string name = default!;
-				int age = default;
-				bool isActive = default;
-				var roles = obj.Roles;
-				var attributes = obj.Attributes;
-
-				var decoder = context.Decoder;
-				context.IncrementDepth();
-
-				long itemsCount;
-				CollectionType arrayOrMap;
-				CollectionItemIterator propertyIterator;
-				while (!TryDecodeArrayOrMapHeader(context, ref memory, out itemsCount, out arrayOrMap, out propertyIterator, out requestHint))
-				{
-					memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-				}
-
-				// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
-				if (arrayOrMap.IsArray)
-				{
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-
-					while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
-
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-
-					while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
-
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-
-					while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
-
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-
-					context.IncrementDepth();
-
-					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						long arrayLength;
-						while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-
-						// If settable
-						//if (roles == null)
-						//{
-						//	roles = new List<string>(arrayLength); // or 0
-						//}
-
-						for (var i = 0; i < arrayLength; i++)
-						{
-							string item;
-							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							roles.Add(item);
-						}
-					}
-					else
-					{
-						CollectionItemIterator iterator;
-						while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-
-						while (!iterator.CollectionEnds(memory, out requestHint))
-						{
-							if (requestHint != 0)
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-
-							string item;
-							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							roles.Add(item);
-						}
-						
-						while(!iterator.Drain(ref memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-					context.DecrementDepth();
-
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-
-					context.IncrementDepth();
-					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					{
-						long mapCount;
-						while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-
-						// If settable
-						//if (attributes == null)
-						//{
-						//	attributes = new Dictionary<string, string>(mapCount); // or 0
-						//}
-						for (var i = 0; i < mapCount; i++)
-						{
-							string key;
-							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							string value;
-							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							attributes.Add(key, value);
-						}
-					}
-					else
-					{
-						CollectionItemIterator iterator;
-						while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-
-						while (!iterator.CollectionEnds(memory, out requestHint))
-						{
-							if (requestHint != 0)
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-
-							string key;
-							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							string value;
-							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							attributes.Add(key, value);
-						}
-
-						while (!iterator.Drain(ref memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
-					}
-					context.DecrementDepth();
-				}
-				else
-				{
-					// Map
-					// #if !context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					// while (!propertyIterator.CollectionEnds(memory, out requestHint))
-					// {
-					//  	if (requestHint != 0)
-					//  	{
-					//  		memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					//			continue;
-					//  	}
-					for (var i = 0; i < itemsCount; i++)
-					{
-						byte[] propertyKey = null!;
-						try
-						{
-							while (!TryGetRawString(context, ref memory, out propertyKey, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-
-							// Use inlined trie, prefixed by the count as MP uint32.
-							// char is UTF-8, big endian.
-							// 1st node: [length(1-5)][chars(7-3)]
-							switch (DeserializationTrie.GetOrDefault(propertyKey))
-							{
-								case 0:
-								{
-									while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
-									{
-										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-									}
-
-									break;
-								}
-								case 1:
-								{
-									while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
-									{
-										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-									}
-
-									break;
-								}
-								case 2:
-								{
-									while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
-									{
-										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-									}
-
-									break;
-								}
-								case 3:
-								{
-									context.IncrementDepth();
-									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-									{
-										long arrayLength;
-										while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
-
-										// If settable
-										//if (roles == null)
-										//{
-										//	roles = new List<string>(arrayLength); // or 0
-										//}
-										for (var j = 0; j < arrayLength; j++)
-										{
-											string item;
-											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											roles.Add(item);
-										}
-									}
-									else
-									{
-										CollectionItemIterator iterator;
-										while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
-
-										while (!iterator.CollectionEnds(memory, out requestHint))
-										{
-											if (requestHint != 0)
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											string item;
-											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											roles.Add(item);
-										}
-
-										while (!iterator.Drain(ref memory, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
-									}
-									context.DecrementDepth();
-									break;
-								}
-								case 4:
-								{
-									context.IncrementDepth();
-									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-									{
-										long mapCount;
-										while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
-
-										// If settable
-										//if (attributes == null)
-										//{
-										//	attributes = new Dictionary<string, string>(mapCount); // or 0
-										//}
-										for (var j = 0; j < mapCount; j++)
-										{
-											string key;
-											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-											string value;
-											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											attributes.Add(key, value);
-										}
-									}
-									else
-									{
-										CollectionItemIterator iterator;
-										while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
-
-										while (!iterator.CollectionEnds(memory, out requestHint))
-										{
-											if (requestHint != 0)
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											string key;
-											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-											string value;
-											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											attributes.Add(key, value);
-										}
-
-										while (!iterator.Drain(ref memory, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
-									}
-									context.DecrementDepth();
-									break;
-								}
-							}
-						}
-						finally
-						{
-							if (propertyKey != null)
-							{
-								context.ArrayPool.Return(propertyKey);
-							}
-						}
-					}
-				}
-
-				if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-				{
-					itemsCount -= 5;
-					while (!TryDrain(context, ref memory, itemsCount, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
-				}
-				else
-				{
-					while(!propertyIterator.Drain(ref memory, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
-				}
-
-				context.DecrementDepth();
-
-				obj.Name = name;
-				obj.Age = age;
-				obj.IsActive = isActive;
-				// If settable
-				// obj.Roles = roles;
-				// If settable
-				// obj.Attributes = attributes;
-			}
-			finally
-			{
-				context.ArrayPool.Return(buffer, clearArray: true);
-			}
-		}
-	}
-
-	public sealed class SampleInt32ArraySerializer<TExtensionType> : IObjectSerializer<int[], TExtensionType>
-	{
-		public void Serialize(in SerializationOperationContext<TExtensionType> context, int[] obj, IBufferWriter<byte> sink)
-		{
-			if (obj is null)
-			{
-				context.Encoder.EncodeNull(sink);
-				return;
-			}
-
-			context.Encoder.EncodeArrayStart(obj.Length, sink, context.CollectionContext);
-			for(var i=0; i <obj.Length;i++)
-			{
-				context.Encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
-				context.Encoder.EncodeInt32(obj[i], sink);
-				context.Encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
-			}
-			context.Encoder.EncodeArrayEnd(obj.Length, sink, context.CollectionContext);
-		}
-
-		public ValueTask SerializeAsync(SerializationOperationContext<TExtensionType> context, int[] obj, Stream streamSink)
-		{
-			throw new NotImplementedException();
-		}
-
-		public int[] Deserialize(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source)
-		{
-			if (context.Decoder.FormatFeatures.CanCountCollectionItems)
-			{
-				var length = context.Decoder.DecodeArrayHeader(source);
-				var result = new int[length];
-				for (var i = 0; i < result.Length; i++)
-				{
-					result[i] = context.Decoder.DecodeInt32(source);
-				}
-				context.Decoder.Drain(source, context.CollectionContext, 0);
-				return result;
-			}
-			else
-			{
-				var result = new List<int>();
-				var iterator = context.Decoder.DecodeArray(source);
-				while (!iterator.CollectionEnds(source))
-				{
-					result.Add(context.Decoder.DecodeInt32(source));
-				}
-				iterator.Drain(source);
-				return result.ToArray();
-			}
-		}
-
-		public ValueTask<int[]> DeserializeAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource)
-		{
-			throw new NotImplementedException();
-		}
-
-		public void DeserializeTo(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source, in int[] obj)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ValueTask DeserializeToAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource, int[] obj)
-		{
-			throw new NotImplementedException();
-		}
-	}
-
-	public sealed class SampleInt32Serializer<TExtensionType> : IObjectSerializer<int, TExtensionType>
-	{
-		public void Serialize(in SerializationOperationContext<TExtensionType> context, int obj, IBufferWriter<byte> sink)
-		{
-			context.Encoder.EncodeInt32(obj, sink);
-		}
-
-		public ValueTask SerializeAsync(SerializationOperationContext<TExtensionType> context, int obj, Stream streamSink)
-		{
-			throw new NotImplementedException();
-		}
-
-		public int Deserialize(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source)
-		{
-			return context.Decoder.DecodeInt32(source);
-		}
-
-		public ValueTask<int> DeserializeAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource)
-		{
-			throw new NotImplementedException();
-		}
-
-		public void DeserializeTo(in DeserializationOperationContext<TExtensionType> context, in SequenceReader<byte> source, in int obj)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ValueTask DeserializeToAsync(DeserializationOperationContext<TExtensionType> context, Stream streamSource, int obj)
-		{
-			throw new NotImplementedException();
-		}
-	}
-}
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
index 408bd801c..ec0a34f72 100644
--- a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
@@ -2,7 +2,12 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 extern alias newmpcli;
+
+using System;
+using System.Buffers;
+using System.Threading;
 using Benchmark.Serializers;
+using MsgPack.Samples;
 
 #pragma warning disable SA1649 // File name should match first type name
 
@@ -35,5 +40,133 @@ internal static class MsgPackCliSerializerRepository<T>
 {
 	public static readonly MsgPack.Serialization.MessagePackSerializer<T> V1 = SampleSerializer.SerializationContext.GetSerializer<T>();
 
+	public static readonly newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType> V2 = InitV2();
+
+	public static readonly newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType> Json = InitJson();
+
+	private static newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType> InitV2()
+	{
+		if (typeof(MsgPack.Samples.SampleObject).IsAssignableFrom(typeof(T)))
+		{
+			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType>)(object)new MsgPack.Samples.SampleSerializer<newmpcli::MsgPack.Internal.MessagePackExtensionType>();
+		}
+		else if (typeof(T) == typeof(int[]))
+		{
+			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType>)(object)new MsgPack.Samples.SampleInt32ArraySerializer<newmpcli::MsgPack.Internal.MessagePackExtensionType>();
+		}
+		else if (typeof(T) == typeof(int))
+		{
+			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType>)(object)new MsgPack.Samples.SampleInt32Serializer<newmpcli::MsgPack.Internal.MessagePackExtensionType>();
+		}
+
+		throw new NotSupportedException($"No {typeof(T)} serializer.");
+	}
+
+	private static newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType> InitJson()
+	{
+		if (typeof(MsgPack.Samples.SampleObject).IsAssignableFrom(typeof(T)))
+		{
+			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType>)(object)new MsgPack.Samples.SampleSerializer<newmpcli::MsgPack.Internal.NullExtensionType>();
+		}
+		else if (typeof(T) == typeof(int[]))
+		{
+			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType>)(object)new MsgPack.Samples.SampleInt32ArraySerializer<newmpcli::MsgPack.Internal.NullExtensionType>();
+		}
+		else if (typeof(T) == typeof(int))
+		{
+			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType>)(object)new MsgPack.Samples.SampleInt32Serializer<newmpcli::MsgPack.Internal.NullExtensionType>();
+		}
+
+		throw new NotSupportedException($"No {typeof(T)} serializer.");
+	}
+
 }
+
+public class MsgPackCli_v2 : SerializerBase
+{
+	private static readonly newmpcli::MsgPack.Internal.MessagePackEncoder Encoder = newmpcli::MsgPack.Internal.MessagePackEncoder.CreateCurrent(newmpcli::MsgPack.Internal.MessagePackEncoderOptions.Default);
+	private static readonly newmpcli::MsgPack.Internal.MessagePackDecoder Decoder = new newmpcli::MsgPack.Internal.MessagePackDecoder(newmpcli::MsgPack.Internal.MessagePackDecoderOptions.Default);
+
+	public override T Deserialize<T>(object input)
+	{
+		var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>((byte[])input));
+		var context =
+			new newmpcli::MsgPack.Serialization.Internal.DeserializationOperationContext<newmpcli::MsgPack.Internal.MessagePackExtensionType>(
+				Decoder,
+				null,
+				CancellationToken.None
+			);
+		return MsgPackCliSerializerRepository<T>.V2.Deserialize(ref context, ref reader);
+	}
+
+	[ThreadStatic]
+	private static ArrayBufferWriter<byte> t_writer;
+
+	public override object Serialize<T>(T input)
+	{
+		if (t_writer == null)
+		{
+			t_writer = new ArrayBufferWriter<byte>(128);
+		}
+		else
+		{
+			t_writer.Clear();
+		}
+
+		var writer = t_writer;
+		var context =
+			new newmpcli::MsgPack.Serialization.Internal.SerializationOperationContext<newmpcli::MsgPack.Internal.MessagePackExtensionType>(
+				Encoder,
+				null,
+				CancellationToken.None
+			);
+		MsgPackCliSerializerRepository<T>.V2.Serialize(ref context, input, writer);
+		return writer.WrittenMemory.ToArray();
+	}
 }
+
+
+
+public class MsgPackCliJson : SerializerBase
+{
+	private static readonly newmpcli::MsgPack.Json.JsonEncoder Encoder = new newmpcli::MsgPack.Json.JsonEncoder(newmpcli::MsgPack.Json.JsonEncoderOptions.Default);
+	private static readonly newmpcli::MsgPack.Json.JsonDecoder Decoder = newmpcli::MsgPack.Json.JsonDecoder.Create(newmpcli::MsgPack.Json.JsonDecoderOptions.Default);
+
+	public override T Deserialize<T>(object input)
+	{
+		var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>((byte[])input));
+		var context =
+			new newmpcli::MsgPack.Serialization.Internal.DeserializationOperationContext<newmpcli::MsgPack.Internal.NullExtensionType>(
+				Decoder,
+				null,
+				CancellationToken.None
+			);
+		return MsgPackCliSerializerRepository<T>.Json.Deserialize(ref context, ref reader);
+	}
+
+	[ThreadStatic]
+	private static ArrayBufferWriter<byte> t_writer;
+
+	public override object Serialize<T>(T input)
+	{
+		if (t_writer == null)
+		{
+			t_writer = new ArrayBufferWriter<byte>(128);
+		}
+		else
+		{
+			t_writer.Clear();
+		}
+
+		var writer = t_writer;
+		var context =
+			new newmpcli::MsgPack.Serialization.Internal.SerializationOperationContext<newmpcli::MsgPack.Internal.NullExtensionType>(
+				Encoder,
+				null,
+				CancellationToken.None
+			);
+		MsgPackCliSerializerRepository<T>.Json.Serialize(ref context, input, writer);
+		return writer.WrittenMemory.ToArray();
+	}
+}
+
diff --git a/test/Benchmark/Program.cs b/test/Benchmark/Program.cs
new file mode 100644
index 000000000..8f436dc9e
--- /dev/null
+++ b/test/Benchmark/Program.cs
@@ -0,0 +1,172 @@
+// Copyright (c) All contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+//#define MSGPACK
+#define JSON
+
+extern alias newmpcli;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Benchmark.Fixture;
+using Benchmark.Models;
+using Benchmark.Serializers;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Running;
+using MessagePack;
+using MsgPack.Samples;
+
+namespace Benchmark
+{
+	internal static class Program
+	{
+		static void Main(string[] args)
+		{
+			//JsonTest();
+			BenchmarkRunner.Run<SampleBenchmark>();
+		}
+
+		static void Test(SerializerBase serializer, SampleObject obj)
+		{
+			Console.WriteLine($"---- {serializer.GetType().Name} ----");
+			var array = serializer.Serialize<SampleObject>(obj);
+			Console.WriteLine((array as byte[])?.Length);
+#if MSGPACK
+			Console.WriteLine(BitConverter.ToString(array as byte[]));
+#else
+			Console.WriteLine(Encoding.UTF8.GetString(array as byte[]));
+#endif
+			var result = serializer.Deserialize<SampleObject>(array);
+			//Console.WriteLine($"Name       : {result?.Name}");
+			//Console.WriteLine($"Age        : {result?.Age}");
+			//Console.WriteLine($"IsActive   : {result?.IsActive}");
+			//Console.WriteLine($"Roles      : [{String.Join(", ", result?.Roles ?? Array.Empty<string>())}]");
+			//Console.WriteLine($"Attributes : {{{String.Join(", ", (result?.Attributes ?? Enumerable.Empty<KeyValuePair<string, string>>()).Select(x => $"{x.Key}: {x.Value}"))}}}");
+		}
+
+		static void JsonTest()
+		{
+			var obj = SampleObject.TestValue;
+				//new SampleObject { Name = "A\tあいうえお\u007F　\\u3042" };
+			//Test(new JsonNet(), obj);
+			Test(new MsgPackCliJson(), obj);
+			//Test(new SpanJson_(), obj);
+			//Test(new SystemTextJson(), obj);
+			//Test(new Utf8Json_(), obj);
+		}
+	}
+
+	[Config(typeof(BenchmarkConfig))]
+	public class SampleBenchmark
+	{
+		[ParamsSource(nameof(Serializers))]
+		public SerializerBase Serializer;
+
+		private bool isContractless;
+
+		// Currently BenchmarkdDotNet does not detect inherited ParamsSource so use copy and paste:)
+		public IEnumerable<SerializerBase> Serializers => new SerializerBase[]
+		{
+#if MSGPACK
+			new MessagePack_v2(),
+#endif
+			//new MsgPack_v2_opt(),
+			//new MessagePackLz4_v2(),
+			//new MsgPack_v2_string(),
+			//new MsgPack_v2_str_lz4(),
+			//new ProtobufNet(),
+#if JSON
+			new JsonNet(),
+#endif
+			//new BinaryFormatter_(),
+			//new DataContract_(),
+			//new Hyperion_(),
+			//new Jil_(),
+#if JSON
+			new SpanJson_(),
+			new Utf8Json_(),
+			new SystemTextJson(),
+			new MsgPackCliJson(),
+#endif
+#if MSGPACK
+
+			new MsgPackCli(),
+			new MsgPackCli_v2(),
+#endif
+			//new FsPickler_(),
+			//new Ceras_(),
+		};
+
+		protected static readonly ExpressionTreeFixture ExpressionTreeFixture = new ExpressionTreeFixture();
+
+		// primitives
+		protected static readonly int IntInput = ExpressionTreeFixture.Create<int>();
+
+		// models
+		protected static readonly SampleObject AnswerInput = SampleObject.TestValue;//  ExpressionTreeFixture.Create<SampleObject>();
+																					// not same data so does not gurantee correctly.
+		protected static readonly SampleObject Answer2Input = SampleObject.TestValue;//ExpressionTreeFixture.Create<SampleObject>();
+
+		private object IntOutput;
+		private object AnswerOutput;
+
+		[GlobalSetup]
+		public void Setup()
+		{
+			this.isContractless = (Serializer is MsgPack_v2_string) || (Serializer is MsgPack_v2_str_lz4);
+
+			// primitives
+			this.IntOutput = this.Serializer.Serialize(IntInput);
+
+			// models
+			if (isContractless)
+			{
+				this.AnswerOutput = this.Serializer.Serialize(Answer2Input);
+			}
+			else
+			{
+				this.AnswerOutput = this.Serializer.Serialize(AnswerInput);
+			}
+
+			var o = this.AnswerOutput as byte[];
+			Console.WriteLine("-------------------------------------------------------------------");
+			Console.WriteLine($"{this.Serializer.GetType().Name} -> {o.Length} bytes");
+			Console.WriteLine(BitConverter.ToString(o));
+			Console.WriteLine("-------------------------------------------------------------------");
+		}
+
+		// Serialize
+		/* [Benchmark] public object _PrimitiveIntSerialize() => this.Serializer.Serialize(IntInput); */
+
+	[Benchmark]
+		public object AnswerSerialize()
+		{
+			if (isContractless)
+			{
+				return this.Serializer.Serialize(Answer2Input);
+			}
+			else
+			{
+				return this.Serializer.Serialize(AnswerInput);
+			}
+		}
+
+		// Deserialize
+		/* [Benchmark] public Int32 _PrimitiveIntDeserialize() => this.Serializer.Deserialize<Int32>(this.IntOutput); */
+
+		[Benchmark]
+		public object AnswerDeserialize()
+		{
+			if (isContractless)
+			{
+				return this.Serializer.Deserialize<SampleObject>(this.AnswerOutput);
+			}
+			else
+			{
+				return this.Serializer.Deserialize<SampleObject>(this.AnswerOutput);
+			}
+		}
+	}
+}
diff --git a/test/Benchmark/_SampleObject.cs b/test/Benchmark/_SampleObject.cs
new file mode 100644
index 000000000..9451254c4
--- /dev/null
+++ b/test/Benchmark/_SampleObject.cs
@@ -0,0 +1,2003 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+//#define USE_ARRAY
+#define INT32
+#define BOOL
+#define STRING
+#define COLLECTION
+#define NO_OPT
+//#define NULL
+//#define INLINE_TRIE
+#define JSON
+
+extern alias newmpcli;
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using newmpcli::MsgPack.Internal;
+using newmpcli::MsgPack.Json;
+using newmpcli::MsgPack.Serialization.Internal;
+
+namespace MsgPack.Samples
+{
+	public delegate ulong TrieKeyFactory(ref ReadOnlySpan<byte> rawPropertyKey);
+
+	public sealed class SerializationFormat
+	{
+		public Type DecoderType { get; set; } // if null, no cast will be used
+		public Type EncoderType { get; set; } // if null, no cast will be used
+		public FormatFeatures Features { get; set; } // if null, no optimization will be applied
+		public Func<string, byte[]> PropertyKeyEncoder { get; set; } // if null, use EncodeString
+		public TrieKeyFactory TrieKeyHeadFactory { get; set; } // if null, use Dictionary<string, int>
+		public TrieKeyFactory TrieKeyRestFactory { get; set; } // if null, use Dictionary<string, int>
+	}
+
+	public sealed class SerializationFormatFactory
+	{
+		public static SerializationFormatFactory Instance { get; } = new SerializationFormatFactory();
+		private SerializationFormatFactory() { }
+	}
+
+	public static class MessagePackSerializationFormatFactoryExtensions
+	{
+		private static readonly SerializationFormat CurrentMessagePackSerializationFormat =
+			new SerializationFormat
+			{
+				DecoderType = typeof(MessagePackDecoder),
+				EncoderType = typeof(MessagePackEncoder), // typeof(CurrentMessagePackEncoder)
+				Features = null, // TODO
+				PropertyKeyEncoder = null, // CurrentMessagePackEncoder.InternalEncodeString,
+				TrieKeyHeadFactory = MsgPackStringTrieKey.GetRaw64,
+				TrieKeyRestFactory = MsgPackStringTrieKey.GetRaw64
+			};
+		private static readonly SerializationFormat LegacyMessagePackSerializationFormat =
+			new SerializationFormat
+			{
+				DecoderType = typeof(MessagePackDecoder),
+				EncoderType = typeof(MessagePackEncoder), // typeof(LegacyMessagePackEncoder)
+				Features = null, // TODO
+				PropertyKeyEncoder = null, // LegacyMessagePackEncoder.InternalEncodeString,
+				TrieKeyHeadFactory = MsgPackStringTrieKey.GetRaw64,
+				TrieKeyRestFactory = MsgPackStringTrieKey.GetRaw64
+			};
+
+		public static SerializationFormat GetMessagePack(this SerializationFormatFactory factory, bool isCurrent = true)
+			=> isCurrent ? CurrentMessagePackSerializationFormat : LegacyMessagePackSerializationFormat;
+	}
+
+
+	public static class JsonSerializationFormatFactoryExtensions
+	{
+		private static readonly SerializationFormat SimpleJsonSerializationFormat =
+			new SerializationFormat
+			{
+				DecoderType = typeof(JsonDecoder), // typeof(SimpleJsonDecoder)
+				EncoderType = typeof(JsonEncoder),
+				Features = null, // TODO
+				PropertyKeyEncoder = null, // JsonEncoder.InternalEncodeString,
+				TrieKeyHeadFactory = MsgPackStringTrieKey.GetAsMsgPackString,
+				TrieKeyRestFactory = MsgPackStringTrieKey.GetRaw64
+			};
+		private static readonly SerializationFormat FlexibleJsonSerializationFormat =
+			new SerializationFormat
+			{
+				DecoderType = typeof(JsonDecoder), // typeof(FlexibleJsonDecoder)
+				EncoderType = typeof(JsonEncoder),
+				Features = null, // TODO
+				PropertyKeyEncoder = null, // JsonEncoder.InternalEncodeString,
+				TrieKeyHeadFactory = MsgPackStringTrieKey.GetAsMsgPackString,
+				TrieKeyRestFactory = MsgPackStringTrieKey.GetRaw64
+			};
+
+		public static SerializationFormat GetJson(this SerializationFormatFactory factory, JsonParseOptions parserOptions)
+			=> parserOptions == JsonParseOptions.None ? SimpleJsonSerializationFormat : FlexibleJsonSerializationFormat;
+	}
+
+#if USE_ARRAY
+	[MessagePack.MessagePackObject(keyAsPropertyName: false)]
+#else
+	[MessagePack.MessagePackObject(keyAsPropertyName: true)]
+#endif
+	public class SampleObject
+	{
+		public static readonly SampleObject TestValue =
+#if NULL
+			null;
+#else
+			new SampleObject()
+			{
+#if INT32
+				Age = 38,
+#endif
+#if STRING
+				Name = "yfakariya",
+#endif
+#if BOOL
+				IsActive = true,
+#endif
+#if COLLECTION
+				Attributes = { ["Busy"] = "Sometimes" },
+				Roles = { "Developer" }
+#endif
+			};
+#endif // NULL
+
+#if INT32
+#if USE_ARRAY
+		[MessagePack.Key(0)]
+#endif
+		public int Age { get; set; }
+#endif
+
+#if STRING
+#if USE_ARRAY
+		[MessagePack.Key(1)]
+#endif
+		public string Name { get; set; } = null!;
+#endif
+
+#if BOOL
+#if USE_ARRAY
+		[MessagePack.Key(2)]
+#endif
+		public bool IsActive { get; set; }
+#endif
+
+#if COLLECTION
+#if USE_ARRAY
+		[MessagePack.Key(3)]
+#endif
+		public IDictionary<string, string> Attributes { get; } = new Dictionary<string, string>();
+
+#if USE_ARRAY
+		[MessagePack.Key(4)]
+#endif
+		public IList<string> Roles { get; } = new List<string>();
+#endif
+	}
+
+	// MP.Core.Abstraction
+	// MP.Core / MP.Json.Core / MP.Yaml.Core / MP.Coff.Core
+	// MP.Serialization.Core -> Interfaces, ....
+	// MP.Serialization -> Basic serializers, context, utilities, Stream adapter, byte[] adapter, etc.
+	// MP.Serialization.Serializers-> Extended serializers implementation.
+	// MP.Serialization.Reflection -> Reflection
+	// MP.Serialization.ILGeneration -> Reflection
+	// MP.Serialization.SourceGeneration -> Reflection
+	// MP.Extensions  / MP.Json.Extensions / MP.Yaml.Extensions / MP.Coff.Extensions -> MPO, DOM, etc
+	// MP.Compatibility1 -> v1 compatibility shims
+	// MP.Cli -> v1 compatibility shims
+
+	// Packer/Unpacker compatibility note:
+	// Packer -> Packer.Create(new MemoryStream())
+	// Unpacker -> Unpacker.Create(new MemoryStream())???
+
+	internal static class SampleSerializer
+	{
+		public static readonly MsgPack.Serialization.SerializationContext SerializationContext =
+#if USE_ARRAY
+			new Serialization.SerializationContext() { SerializationMethod = Serialization.SerializationMethod.Array };
+#else
+			new Serialization.SerializationContext() { SerializationMethod = Serialization.SerializationMethod.Map };
+#endif
+	}
+
+	// For PoC of MVP and reference for emit.
+	/// <summary>
+	///		Sample hand made serializer.
+	/// </summary>
+	public sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleObject, TExtensionType>
+	{
+		private bool UseArray { get; set; }
+#if USE_ARRAY
+			= true;
+#endif
+		private FormatFeatures FormatFeatures { get; set; } =
+			new FormatFeaturesBuilder
+			{
+#if MSGPACK
+				CanCountCollectionItems = true,
+				CanSpecifyStringEncoding = true,
+				IsContextful = false,
+				SupportsExtensionTypes = true
+#else
+				CanCountCollectionItems = false,
+				CanSpecifyStringEncoding = false,
+				IsContextful = false,
+				SupportsExtensionTypes = false
+#endif
+			}.Build();
+
+		public void Serialize(ref SerializationOperationContext<TExtensionType> context, SampleObject obj, IBufferWriter<byte> writer)
+		{
+#if JSON
+			var encoder = new JsonEncoder(context.Encoder.Options as JsonEncoderOptions);
+#elif NO_OPT
+			var encoder = context.Encoder;
+#else
+			var encoder = context.Encoder;
+#endif
+			if (obj == null)
+			{
+				encoder.EncodeNull(writer);
+				return;
+			}
+
+			const int propertyCount =
+					0
+#if INT32
+					+ 1
+#endif
+#if STRING
+					+ 1
+#endif
+#if BOOL
+					+ 1
+#endif
+#if COLLECTION
+					+ 1
+					+ 1
+#endif
+					;
+			//if (this.UseArray)
+#if USE_ARRAY
+			{
+				encoder.EncodeArrayStart(propertyCount, writer, context.CollectionContext); // OMITTABLE
+#if STRING
+#if NO_OPT
+				encoder.EncodeArrayItemStart(0, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeString(obj.Name, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+
+#if NO_OPT
+				encoder.EncodeArrayItemEnd(0, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif
+#if INT32
+#if NO_OPT
+				encoder.EncodeArrayItemStart(1, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeInt32(obj.Age, writer);
+#if NO_OPT
+				encoder.EncodeArrayItemEnd(1, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif
+#if BOOL
+#if NO_OPT
+				encoder.EncodeArrayItemStart(2, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeBoolean(obj.IsActive, writer);
+#if NO_OPT
+				encoder.EncodeArrayItemEnd(2, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif // BOOL
+#if COLLECTION
+#if NO_OPT
+				encoder.EncodeArrayItemStart(3, writer, context.CollectionContext); // OMITTABLE
+#endif
+				if (obj.Roles == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeArrayStart(obj.Roles.Count, writer, context.CollectionContext); // OMITTABLE
+					context.IncrementDepth();
+					var roles = obj.Roles;
+					var count = roles.Count;
+					for (var i = 0; i < count; i++)
+					{
+#if NO_OPT
+						encoder.EncodeArrayItemStart(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+						encoder.EncodeString(roles[i], writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+						encoder.EncodeArrayItemEnd(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+					}
+					context.DecrementDepth();
+#if NO_OPT
+					encoder.EncodeArrayEnd(obj.Roles.Count, writer, context.CollectionContext);
+#endif
+				}
+#if NO_OPT
+				encoder.EncodeArrayItemEnd(3, writer, context.CollectionContext); // OMITTABLE
+
+				encoder.EncodeArrayItemStart(4, writer, context.CollectionContext); // OMITTABLE
+#endif
+				if (obj.Attributes == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeMapStart(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
+					context.IncrementDepth();
+#if NO_OPT
+					var i = 0; // OMITTABLE
+#endif
+					foreach (var entry in obj.Attributes)
+					{
+#if NO_OPT
+						encoder.EncodeMapKeyStart(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+						encoder.EncodeString(entry.Key, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+						encoder.EncodeMapKeyEnd(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeMapValueStart(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+						encoder.EncodeString(entry.Value, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+						encoder.EncodeMapValueEnd(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+					}
+					context.DecrementDepth();
+#if NO_OPT
+					encoder.EncodeMapEnd(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
+#endif
+				}
+#if NO_OPT
+				encoder.EncodeArrayItemEnd(4, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif // COLLECTION
+#if NO_OPT
+				encoder.EncodeArrayEnd(propertyCount, writer, context.CollectionContext);
+#endif
+					}
+#else // USEARRAY
+			//else
+			{
+				encoder.EncodeMapStart(propertyCount, writer, context.CollectionContext); // OMITTABLE
+
+#if STRING
+#if JSON
+				ReadOnlySpan<byte> key0 = new[] { (byte)'"', (byte)'N', (byte)'a', (byte)'m', (byte)'e', (byte)'"' }; // static readonly
+#else
+				ReadOnlySpan<byte> key0 = new[] { 0xA4, (byte)'N', (byte)'a', (byte)'m', (byte)'e' }; // static readonly
+#endif
+#warning TODO: Use DirectWrite
+#if NO_OPT
+				encoder.EncodeMapKeyStart(0, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeRawString(key0, 4, writer, context.CancellationToken);
+#if NO_OPT
+				encoder.EncodeMapKeyEnd(0, writer, context.CollectionContext); // OMITTABLE
+				encoder.EncodeMapValueStart(0, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeString(obj.Name, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+				encoder.EncodeMapValueEnd(0, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif // STRING
+#if INT32
+#if JSON
+				ReadOnlySpan<byte> key1 = new[] { (byte)'"', (byte)'A', (byte)'g', (byte)'e', (byte)'"' }; // static readonly
+#else
+				ReadOnlySpan<byte> key1 = new[] { 0xA3, (byte)'A', (byte)'g', (byte)'e' }; // static readonly
+#endif
+#if NO_OPT
+				encoder.EncodeMapKeyStart(1, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeRawString(key1, 3, writer, context.CancellationToken);
+#if NO_OPT
+				encoder.EncodeMapKeyEnd(1, writer, context.CollectionContext); // OMITTABLE
+				encoder.EncodeMapValueStart(1, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeInt32(obj.Age, writer);
+#if NO_OPT
+				encoder.EncodeMapValueEnd(1, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif // INT32
+#if BOOL
+#if JSON
+				ReadOnlySpan<byte> key2 = new[] { (byte)'"', (byte)'I', (byte)'s', (byte)'A', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e', (byte)'"' }; // static readonly
+#else
+				ReadOnlySpan<byte> key2 = new[] { 0xA8, (byte)'I', (byte)'s', (byte)'A', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e' }; // static readonly
+#endif
+#if NO_OPT
+				encoder.EncodeMapKeyStart(2, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeRawString(key2, 8, writer, context.CancellationToken);
+#if NO_OPT
+				encoder.EncodeMapKeyEnd(2, writer, context.CollectionContext); // OMITTABLE
+				encoder.EncodeMapValueStart(2, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeBoolean(obj.IsActive, writer);
+#if NO_OPT
+				encoder.EncodeMapValueEnd(2, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif // BOOL
+#if COLLECTION
+#if JSON
+				ReadOnlySpan<byte> key3 = new[] { (byte)'"', (byte)'R', (byte)'o', (byte)'l', (byte)'e', (byte)'s', (byte)'"' }; // static readonly
+#else
+				ReadOnlySpan<byte> key3 = new[] { 0xA5, (byte)'R', (byte)'o', (byte)'l', (byte)'e', (byte)'s' }; // static readonly
+#endif
+#if NO_OPT
+				encoder.EncodeMapKeyStart(3, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeRawString(key3, 5, writer, context.CancellationToken);
+#if NO_OPT
+				encoder.EncodeMapKeyEnd(3, writer, context.CollectionContext); // OMITTABLE
+				encoder.EncodeMapValueStart(3, writer, context.CollectionContext); // OMITTABLE
+#endif
+				if (obj.Roles == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeArrayStart(obj.Roles.Count, writer, context.CollectionContext); // OMITTABLE
+					context.IncrementDepth();
+#if NO_OPT
+					var i = 0; // OMITTABLE
+#endif
+					foreach (var item in obj.Roles)
+					{
+#if NO_OPT
+						encoder.EncodeArrayItemStart(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+						encoder.EncodeString(item, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+						encoder.EncodeArrayItemEnd(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+					}
+					context.DecrementDepth();
+#if NO_OPT
+					encoder.EncodeArrayEnd(obj.Roles.Count, writer, context.CollectionContext); // OPTIMIZABLE
+#endif
+				}
+#if NO_OPT
+				encoder.EncodeMapValueEnd(3, writer, context.CollectionContext); // OMITTABLE
+#endif
+
+#if JSON
+				ReadOnlySpan<byte> key4 = new[] { (byte)'"', (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s', (byte)'"' }; // static readonly
+#else
+				ReadOnlySpan<byte> key4 = new[] { 0xAA, (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s' }; // static readonly
+#endif
+#if NO_OPT
+				encoder.EncodeMapKeyStart(4, writer, context.CollectionContext); // OMITTABLE
+#endif
+				encoder.EncodeRawString(key4, 10, writer, context.CancellationToken);
+#if NO_OPT
+				encoder.EncodeMapKeyEnd(4, writer, context.CollectionContext); // OMITTABLE
+				encoder.EncodeMapValueStart(4, writer, context.CollectionContext); // OMITTABLE
+#endif
+				if (obj.Attributes == null)
+				{
+					encoder.EncodeNull(writer);
+				}
+				else
+				{
+					encoder.EncodeMapStart(obj.Attributes.Count, writer, context.CollectionContext); // OMITTABLE
+					context.IncrementDepth();
+					var i = 0; // OMITTABLE
+					foreach (var entry in obj.Attributes)
+					{
+#if NO_OPT
+						encoder.EncodeMapKeyStart(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+						encoder.EncodeString(entry.Key, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+						encoder.EncodeMapKeyEnd(i, writer, context.CollectionContext); // OMITTABLE
+						encoder.EncodeMapValueStart(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+						encoder.EncodeString(entry.Value, writer, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#if NO_OPT
+						encoder.EncodeMapValueEnd(i, writer, context.CollectionContext); // OMITTABLE
+#endif
+					}
+					context.DecrementDepth();
+					encoder.EncodeMapEnd(obj.Attributes.Count, writer, context.CollectionContext);
+				}
+#if NO_OPT
+				encoder.EncodeMapValueEnd(4, writer, context.CollectionContext); // OMITTABLE
+#endif
+#endif // COLLECTION
+#if NO_OPT
+				encoder.EncodeMapEnd(propertyCount, writer, context.CollectionContext);
+#endif
+			}
+#endif // !USE_ARRAY
+		}
+
+		public async ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, SampleObject obj, Stream streamSink)
+		{
+			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
+			{
+				var serializationOperationContext = context.AsSerializationOperationContext();
+				this.Serialize(ref serializationOperationContext, obj, writer);
+			}
+		}
+
+		private static readonly MsgPackStringTrie<uint> DeserializationTrie = InitializeDeserializationTrie();
+		private static MsgPackStringTrie<uint> InitializeDeserializationTrie()
+		{
+			ReadOnlySpan<byte> __name = new byte[] { (byte)'N', (byte)'a', (byte)'m', (byte)'e' };
+			ReadOnlySpan<byte> __age = new byte[] { (byte)'A', (byte)'g', (byte)'e' };
+			ReadOnlySpan<byte> __isActive = new byte[] { (byte)'I', (byte)'s', (byte)'A', (byte)'c', (byte)'t', (byte)'i', (byte)'v', (byte)'e' };
+			ReadOnlySpan<byte> __roles = new byte[] { (byte)'R', (byte)'o', (byte)'l', (byte)'e', (byte)'s' };
+			ReadOnlySpan<byte> __attributes = new byte[] { (byte)'A', (byte)'t', (byte)'t', (byte)'r', (byte)'i', (byte)'b', (byte)'u', (byte)'t', (byte)'e', (byte)'s' };
+			var trie = new MsgPackStringTrie<uint>(5);
+#if !JSON
+#if STRING
+			trie.TryAdd(__name, 0);
+#endif
+#if INT32
+			trie.TryAdd(__age, 1);
+#endif
+#if BOOL
+			trie.TryAdd(__isActive, 2);
+#endif
+#if COLLECTION
+			trie.TryAdd(__roles, 3);
+			trie.TryAdd(__attributes, 4);
+#endif
+#else
+#if STRING
+			trie.TryAddRaw(__name, 0);
+#endif
+#if INT32
+			trie.TryAddRaw(__age, 1);
+#endif
+#if BOOL
+			trie.TryAddRaw(__isActive, 2);
+#endif
+#if COLLECTION
+			trie.TryAddRaw(__roles, 3);
+			trie.TryAddRaw(__attributes, 4);
+#endif
+#endif
+			//			var trie32 = new MsgPackStringTrie32<uint>(5);
+			//#if STRING
+			//			trie32.TryAdd(__name, 0);
+			//#endif
+			//#if INT32
+			//			trie32.TryAdd(__age, 1);
+			//#endif
+			//#if BOOL
+			//			trie32.TryAdd(__isActive, 2);
+			//#endif
+			//#if COLLECTION
+			//			trie32.TryAdd(__roles, 3);
+			//			trie32.TryAdd(__attributes, 4);
+			//#endif
+			Console.WriteLine(String.Join(Environment.NewLine, trie.GetDebugView().Select(x => $"{String.Join('-', x.Keys.Select(l => l.ToString("X8")))} = {x.Value}")));
+
+			return trie;
+		}
+
+		public SampleObject Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> reader)
+		{
+#warning TODO: Inlining to avoid allocation when null.
+			// WHEN T is reference type and it has a default contractor -> DeserializeToAsync
+			var obj = new SampleObject();
+			if (this.DeserializeTo(ref context, ref reader, obj))
+			{
+				return obj;
+			}
+			else
+			{
+				// WHEN T is not nullable, then throw.
+				return null;
+			}
+
+			// WHEN T does not have default constructor -> Inline implementation which is same as  DeserializeToAsync
+			// ....
+			// return new SampleObject(name, age, isActive, roles, attributes);
+
+			// WHEN T is mutable value type
+			// ...
+			// var obj = default;
+			// obj.Name = name;
+			// obj.Age = age;
+			// obj.IsActive = isActive;
+			// obj.Roles = roles; // Roles must be null
+			// obj.Attributes = attributes; // Attributes must be null
+			// return obj;
+		}
+
+		public async ValueTask<SampleObject> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		{
+			var obj = new SampleObject();
+			// WHEN T is reference type and it has a default contractor -> DeserializeToAsync
+			if (await this.DeserializeToAsync(context, streamSource, obj).ConfigureAwait(false))
+			{
+				return obj;
+			}
+			else
+			{
+				// WHEN T is not nullable, then throw.
+				return null;
+			}
+
+			// WHEN T does not have default constructor -> Inline implementation which is same as  DeserializeToAsync
+			// ....
+			// return new SampleObject(name, age, isActive, roles, attributes);
+
+			// WHEN T is mutable value type
+			// ...
+			// var obj = default;
+			// obj.Name = name;
+			// obj.Age = age;
+			// obj.IsActive = isActive;
+			// obj.Roles = roles; // Roles must be null
+			// obj.Attributes = attributes; // Attributes must be null
+			// return obj;
+		}
+
+		private static void ThrowNotEnoughItems(long actual, int expected)
+			=> throw new MessageTypeException();
+
+		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> reader, in SampleObject obj)
+		{
+			const int propertyCount =
+					0
+#if INT32
+					+ 1
+#endif
+#if STRING
+					+ 1
+#endif
+#if BOOL
+					+ 1
+#endif
+#if USE_ARRAY
+					+ 1
+					+ 1
+#endif
+					;
+#if STRING
+			string name = default!;
+#endif
+#if INT32
+			int age = default;
+#endif
+#if BOOL
+			bool isActive = default;
+#endif
+#if COLLECTION
+			var roles = obj.Roles;
+			var attributes = obj.Attributes;
+#endif
+
+#if JSON
+			var decoder = (JsonDecoder)(object)context.Decoder;
+#elif NO_OPT
+			var decoder = context.Decoder;
+#else
+			var decoder = new MessagePackDecoder(context.Decoder.Options as MessagePackDecoderOptions);
+#endif
+			CollectionType arrayOrMap;
+			long itemsCount;
+			CollectionItemIterator propertyIterator;
+
+			if (this.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+				arrayOrMap = decoder.DecodeArrayOrMapHeader(ref reader, out itemsCount);
+				if (arrayOrMap.IsNull)
+				{
+#warning TODO: result = null;
+					return false;
+				}
+
+				if (itemsCount < propertyCount)
+				{
+					ThrowNotEnoughItems(itemsCount, propertyCount);
+				}
+
+				propertyIterator = default;
+			}
+			else
+			{
+				arrayOrMap = decoder.DecodeArrayOrMap(ref reader, out propertyIterator);
+				if (arrayOrMap.IsNull)
+				{
+#warning TODO: result = null;
+					return false;
+				}
+				itemsCount = -1;
+			}
+
+			// Instantiate object for Deserialize
+
+			context.IncrementDepth();
+
+			// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
+			if (arrayOrMap.IsArray)
+			{
+#if STRING
+#if NO_OPT
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(ref reader, ref propertyIterator);
+				}
+#endif
+
+				name = decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+#endif
+
+#if INT32
+#if NO_OPT
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(ref reader, ref propertyIterator);
+				}
+#endif
+
+				age = decoder.DecodeInt32(ref reader);
+#endif
+
+#if BOOL
+#if NO_OPT
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(ref reader, ref propertyIterator);
+				}
+#endif
+
+				isActive = decoder.DecodeBoolean(ref reader);
+#endif
+
+#if COLLECTION
+#if NO_OPT
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(ref reader, ref propertyIterator);
+				}
+#endif
+
+				context.IncrementDepth();
+#if NO_OPT
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+#endif
+					var arrayLength = decoder.DecodeArrayHeader(ref reader);
+					// If settable
+					//if (roles == null)
+					//{
+					//	roles = new List<string>(arrayLength); // or 0
+					//}
+
+					for (var i = 0; i < arrayLength; i++)
+					{
+						roles.Add(decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+					}
+#if NO_OPT
+				}
+				else
+				{
+					var iterator = decoder.DecodeArray(ref reader);
+					while (!iterator.CollectionEnds(ref reader))
+					{
+						roles.Add(decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+					}
+					iterator.Drain(ref reader);
+				}
+#endif
+				context.DecrementDepth();
+
+#if NO_OPT
+				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					CheckNextItemExists(ref reader, ref propertyIterator);
+				}
+#endif
+				context.IncrementDepth();
+#if NO_OPT
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+#endif
+					var mapCount = decoder.DecodeMapHeader(ref reader);
+					// If settable
+					//if (attributes == null)
+					//{
+					//	attributes = new Dictionary<string, string>(mapCount); // or 0
+					//}
+					for (var i = 0; i < mapCount; i++)
+					{
+						attributes.Add(
+							decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+							decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+						);
+					}
+#if NO_OPT
+				}
+				else
+				{
+					var iterator = decoder.DecodeMap(ref reader);
+					while (!iterator.CollectionEnds(ref reader))
+					{
+						attributes.Add(
+							decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+							decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+						);
+					}
+					iterator.Drain(ref reader);
+				}
+#endif
+				context.DecrementDepth();
+#endif
+			}
+			else
+			{
+				// Map
+
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					for (var i = 0; i < itemsCount; i++)
+					{
+#warning For msgpack, it should contain header, For JSON, it should contain ...? -> For Collection
+						decoder.GetRawString(ref reader, out ReadOnlySpan<byte> key, context.CancellationToken);
+
+						context.ValidatePropertyKeyLength(reader.Consumed, key.Length);
+
+						// Use inlined trie, prefixed by the count as MP uint32.
+						// char is UTF-8, big endian.
+						// 1st node: [length(1-5)][chars(7-3)]
+
+#if INLINE_TRIE
+						// TODO: 64bit, binary search
+						//417349A8-76697463-00000065 = 2
+						//656741A3 = 1
+						//6C6F52A5-00007365 = 3
+						//6D614EA4-00000065 = 0
+						//747441AA-75626972-00736574 = 4					
+						var intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+						switch (intKey)
+#else
+						switch (DeserializationTrie.GetOrDefault(key))
+#endif // INLINE_TRIE
+						{
+#if STRING
+#if INLINE_TRIE
+							case 0x6D614EA4:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00000065)
+								{
+									goto default;
+								}
+#else
+							case 0:
+							{
+#endif
+
+								name = decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+								break;
+							}
+#endif
+#if INT32
+#if INLINE_TRIE
+							case 0x656741A3:
+#else
+							case 1:
+#endif
+							{
+								age = decoder.DecodeInt32(ref reader);
+								break;
+							}
+#endif
+#if BOOL
+#if INLINE_TRIE
+							case 0x417349A8:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x76697463)
+								{
+									goto default;
+								}
+
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00000065)
+								{
+									goto default;
+								}
+#else
+							case 2:
+							{
+#endif
+								isActive = decoder.DecodeBoolean(ref reader);
+								break;
+							}
+#endif
+#if COLLECTION
+#if INLINE_TRIE
+							case 0x6C6F52A5:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00007365)
+								{
+									goto default;
+								}
+
+#else
+							case 3:
+							{
+#endif
+#warning TODO: No Collection items deserialized!
+								context.IncrementDepth();
+								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								{
+									var arrayLength = decoder.DecodeArrayHeader(ref reader);
+									// If settable
+									//if (roles == null)
+									//{
+									//	roles = new List<string>(arrayLength); // or 0
+									//}
+									for (var j = 0; j < arrayLength; j++)
+									{
+										roles.Add(decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+									}
+								}
+								else
+								{
+									var iterator = decoder.DecodeArray(ref reader);
+									while (!iterator.CollectionEnds(ref reader))
+									{
+										roles.Add(decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+									}
+									iterator.Drain(ref reader);
+								}
+								context.DecrementDepth();
+								break;
+							}
+#if INLINE_TRIE
+							case 0x747441AA:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x75626972)
+								{
+									goto default;
+								}
+
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00736574)
+								{
+									goto default;
+								}
+#else
+							case 4:
+							{
+#endif
+								context.IncrementDepth();
+								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								{
+									var mapCount = decoder.DecodeMapHeader(ref reader);
+									// If settable
+									//if (attributes == null)
+									//{
+									//	attributes = new Dictionary<string, string>(mapCount); // or 0
+									//}
+									for (var j = 0; j < mapCount; j++)
+									{
+										attributes.Add(
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+										);
+									}
+								}
+								else
+								{
+									var iterator = decoder.DecodeMap(ref reader);
+									while (!iterator.CollectionEnds(ref reader))
+									{
+										attributes.Add(
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+										);
+									}
+									iterator.Drain(ref reader);
+								}
+								context.DecrementDepth();
+								break;
+							}
+#endif
+							default:
+							{
+								context.Decoder.Skip(ref reader, context.CollectionContext, context.CancellationToken);
+								break;
+							}
+						}
+					}
+				}
+				else
+				{
+					while (!propertyIterator.CollectionEnds(ref reader))
+					{
+#warning For msgpack, it should contain header, For JSON, it should contain ...? -> For Collection
+						decoder.GetRawString(ref reader, out ReadOnlySpan<byte> key, context.CancellationToken);
+
+						context.ValidatePropertyKeyLength(reader.Consumed, key.Length);
+
+						CheckNextItemExists(ref reader, ref propertyIterator);
+
+						// Use inlined trie, prefixed by the count as MP uint32.
+						// char is UTF-8, big endian.
+						// 1st node: [length(1-5)][chars(7-3)]
+
+#if INLINE_TRIE
+						// TODO: 64bit, binary search
+						//417349A8-76697463-00000065 = 2
+						//656741A3 = 1
+						//6C6F52A5-00007365 = 3
+						//6D614EA4-00000065 = 0
+						//747441AA-75626972-00736574 = 4					
+						var intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+						switch (intKey)
+#else
+						switch (DeserializationTrie.GetOrDefault(key))
+#endif // INLINE_TRIE
+						{
+#if STRING
+#if INLINE_TRIE
+							case 0x6D614EA4:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00000065)
+								{
+									goto default;
+								}
+#else
+							case 0:
+							{
+#endif
+
+								name = decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+								break;
+							}
+#endif
+#if INT32
+#if INLINE_TRIE
+							case 0x656741A3:
+#else
+							case 1:
+#endif
+							{
+								age = decoder.DecodeInt32(ref reader);
+								break;
+							}
+#endif
+#if BOOL
+#if INLINE_TRIE
+							case 0x417349A8:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x76697463)
+								{
+									goto default;
+								}
+
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00000065)
+								{
+									goto default;
+								}
+#else
+							case 2:
+							{
+#endif
+								isActive = decoder.DecodeBoolean(ref reader);
+								break;
+							}
+#endif
+#if COLLECTION
+#if INLINE_TRIE
+							case 0x6C6F52A5:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00007365)
+								{
+									goto default;
+								}
+
+#else
+							case 3:
+							{
+#endif
+#warning TODO: No Collection items deserialized!
+								context.IncrementDepth();
+								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								{
+									var arrayLength = decoder.DecodeArrayHeader(ref reader);
+									// If settable
+									//if (roles == null)
+									//{
+									//	roles = new List<string>(arrayLength); // or 0
+									//}
+									for (var j = 0; j < arrayLength; j++)
+									{
+										roles.Add(decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+									}
+								}
+								else
+								{
+									var iterator = decoder.DecodeArray(ref reader);
+									while (!iterator.CollectionEnds(ref reader))
+									{
+										roles.Add(decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken)); // <>NameEncoding ?? context.StringEncoding
+									}
+									iterator.Drain(ref reader);
+								}
+								context.DecrementDepth();
+								break;
+							}
+#if INLINE_TRIE
+							case 0x747441AA:
+							{
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x75626972)
+								{
+									goto default;
+								}
+
+								intKey = MsgPackStringTrieKey.GetRaw64(ref key);
+								if (intKey != 0x00736574)
+								{
+									goto default;
+								}
+#else
+							case 4:
+							{
+#endif
+								context.IncrementDepth();
+								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								{
+									var mapCount = decoder.DecodeMapHeader(ref reader);
+									// If settable
+									//if (attributes == null)
+									//{
+									//	attributes = new Dictionary<string, string>(mapCount); // or 0
+									//}
+									for (var j = 0; j < mapCount; j++)
+									{
+										attributes.Add(
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken), // <>NameEncoding ?? context.StringEncoding
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+										);
+									}
+								}
+								else
+								{
+									var iterator = decoder.DecodeMap(ref reader);
+									while (!iterator.CollectionEnds(ref reader))
+									{
+										var attributesKey = decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken); // <>NameEncoding ?? context.StringEncoding
+										CheckNextItemExists(ref reader, ref iterator);
+										attributes.Add(
+											attributesKey,
+											decoder.DecodeString(ref reader, context.StringEncoding, context.CancellationToken) // <>NameEncoding ?? context.StringEncoding
+										);
+									}
+									iterator.Drain(ref reader);
+								}
+								context.DecrementDepth();
+								break;
+							}
+#endif
+							default:
+							{
+								context.Decoder.Skip(ref reader, context.CollectionContext, context.CancellationToken);
+								break;
+							}
+						}
+					}
+
+				}
+			}
+
+#if NO_OPT
+			if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+#endif
+				decoder.Drain(ref reader, context.CollectionContext, itemsCount - 5, context.CancellationToken);
+#if NO_OPT
+			}
+			else
+			{
+				propertyIterator.Drain(ref reader);
+			}
+#endif
+
+			context.DecrementDepth();
+
+			// They are verbose for Deserialize
+#if STRING
+			obj.Name = name;
+#endif
+#if INT32
+			obj.Age = age;
+#endif
+#if BOOL
+			obj.IsActive = isActive;
+#endif
+			// If settable
+			// obj.Roles = roles;
+			// If settable
+			// obj.Attributes = attributes;
+			return true;
+		}
+
+		private static void CheckNextItemExists(ref SequenceReader<byte> reader, ref CollectionItemIterator propertyIterator)
+		{
+			if (propertyIterator.CollectionEnds(ref reader))
+			{
+				throw new MessageTypeException(); // Use Throws
+			}
+		}
+
+		private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
+		{
+			context.IncrementDepth();
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(ref reader, out itemsCount, out requestHint);
+			if (arrayOrMap.IsNone)
+			{
+				propertyIterator = default;
+				return false;
+			}
+
+			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+				arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(ref reader, out itemsCount);
+				if (itemsCount < 5)
+				{
+					throw new MessageTypeException(); // Use Throws
+				}
+
+				propertyIterator = default;
+			}
+			else
+			{
+				arrayOrMap = context.Decoder.DecodeArrayOrMap(ref reader, out propertyIterator);
+				itemsCount = -1;
+			}
+
+			memory = memory.Slice(unchecked((int)reader.Consumed));
+
+			return true;
+		}
+
+		private static bool TryDecodeArrayHeader(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long arrayLength, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			arrayLength = context.Decoder.DecodeArrayHeader(ref reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeMapHeader(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long mapCount, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			mapCount = context.Decoder.DecodeMapHeader(ref reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfName(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string name, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			name = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfAge(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out int age, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			age = context.Decoder.DecodeInt32(ref reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfIsActive(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out bool isActive, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			isActive = context.Decoder.DecodeBoolean(ref reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeItemOfRoles(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string item, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			item = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeKeyOfAttributes(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string key, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			key = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeValueOfAttributes(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string value, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			value = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeArray(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			iterator = context.Decoder.DecodeArray(ref reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryDecodeMap(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			iterator = context.Decoder.DecodeMap(ref reader, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private static bool TryGetRawString(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, [NotNullWhen(true)] out byte[] key, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+
+			ReadOnlySpan<byte> span;
+			if (!context.Decoder.GetRawString(ref reader, out span, out requestHint, context.CancellationToken))
+			{
+				key = default!;
+				return false;
+			}
+
+			key = context.ByteBufferPool.Rent(span.Length);
+			span.CopyTo(key);
+			return true;
+		}
+
+		private static bool TryDrain(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, long remaining, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			context.Decoder.Drain(ref reader, context.CollectionContext, remaining, out requestHint);
+			if (requestHint == 0)
+			{
+				memory = memory.Slice(unchecked((int)reader.Consumed));
+			}
+			return requestHint == 0;
+		}
+
+		private bool TryCheckNextItemExists(ref CollectionItemIterator propertyIterator, ReadOnlyMemory<byte> memory, out int requestHint)
+		{
+			if (propertyIterator.CollectionEnds(memory, out requestHint))
+			{
+				throw new MessageTypeException(); // use throws
+			}
+
+			return requestHint == 0;
+		}
+
+		public async ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, SampleObject obj)
+		{
+			// T が値型
+			// throw new NotSupportedException();
+
+			var buffer = context.ByteBufferPool.Rent(2 * 1024 * 1024);
+			try
+			{
+				var provider = new StreamReadOnlyMemoryProvider(streamSource, buffer);
+				var memory = await provider.GetNextAsync(default, 0, context.CancellationToken).ConfigureAwait(false);
+				int requestHint;
+
+#if STRING
+				string name = default!;
+#endif
+#if INT32
+				int age = default;
+#endif
+#if BOOL
+				bool isActive = default;
+#endif
+#if COLLECTION
+				var roles = obj.Roles;
+				var attributes = obj.Attributes;
+#endif
+
+				var decoder = context.Decoder;
+				context.IncrementDepth();
+
+				long itemsCount;
+				CollectionType arrayOrMap;
+				CollectionItemIterator propertyIterator;
+				while (!TryDecodeArrayOrMapHeader(context, ref memory, out itemsCount, out arrayOrMap, out propertyIterator, out requestHint))
+				{
+					memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+				}
+
+				if (arrayOrMap.IsNull)
+				{
+					return false;
+				}
+
+				// Instantiate when Deserialize
+
+				// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
+				if (arrayOrMap.IsArray)
+				{
+#if STRING
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+#endif
+
+#if INT32
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+#endif
+
+#if BOOL
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+#endif
+
+#if COLLECTION
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					context.IncrementDepth();
+
+					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						long arrayLength;
+						while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						// If settable
+						//if (roles == null)
+						//{
+						//	roles = new List<string>(arrayLength); // or 0
+						//}
+
+						for (var i = 0; i < arrayLength; i++)
+						{
+							string item;
+							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							roles.Add(item);
+						}
+					}
+					else
+					{
+						CollectionItemIterator iterator;
+						while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						while (!iterator.CollectionEnds(memory, out requestHint))
+						{
+							if (requestHint != 0)
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+
+							string item;
+							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							roles.Add(item);
+						}
+
+						while (!iterator.Drain(ref memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+					context.DecrementDepth();
+
+					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+
+					context.IncrementDepth();
+					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					{
+						long mapCount;
+						while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						// If settable
+						//if (attributes == null)
+						//{
+						//	attributes = new Dictionary<string, string>(mapCount); // or 0
+						//}
+						for (var i = 0; i < mapCount; i++)
+						{
+							string key;
+							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							string value;
+							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							attributes.Add(key, value);
+						}
+					}
+					else
+					{
+						CollectionItemIterator iterator;
+						while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+
+						while (!iterator.CollectionEnds(memory, out requestHint))
+						{
+							if (requestHint != 0)
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+
+							string key;
+							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							string value;
+							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+							attributes.Add(key, value);
+						}
+
+						while (!iterator.Drain(ref memory, out requestHint))
+						{
+							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+					context.DecrementDepth();
+#endif
+				}
+				else
+				{
+					// Map
+					// #if !context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					// while (!propertyIterator.CollectionEnds(memory, out requestHint))
+					// {
+					//  	if (requestHint != 0)
+					//  	{
+					//  		memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					//			continue;
+					//  	}
+					for (var i = 0; i < itemsCount; i++)
+					{
+						byte[] propertyKey = null!;
+						try
+						{
+							while (!TryGetRawString(context, ref memory, out propertyKey, out requestHint))
+							{
+								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							}
+
+							// Use inlined trie, prefixed by the count as MP uint32.
+							// char is UTF-8, big endian.
+							// 1st node: [length(1-5)][chars(7-3)]
+							switch (DeserializationTrie.GetOrDefault(propertyKey))
+							{
+#if STRING
+								case 0:
+								{
+									while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
+									{
+										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									break;
+								}
+#endif
+#if INT32
+								case 1:
+								{
+									while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
+									{
+										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									break;
+								}
+#endif
+#if BOOL
+								case 2:
+								{
+									while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
+									{
+										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									break;
+								}
+#endif
+#if COLLECTION
+								case 3:
+								{
+									context.IncrementDepth();
+									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+									{
+										long arrayLength;
+										while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										// If settable
+										//if (roles == null)
+										//{
+										//	roles = new List<string>(arrayLength); // or 0
+										//}
+										for (var j = 0; j < arrayLength; j++)
+										{
+											string item;
+											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											roles.Add(item);
+										}
+									}
+									else
+									{
+										CollectionItemIterator iterator;
+										while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										while (!iterator.CollectionEnds(memory, out requestHint))
+										{
+											if (requestHint != 0)
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											string item;
+											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											roles.Add(item);
+										}
+
+										while (!iterator.Drain(ref memory, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+									}
+									context.DecrementDepth();
+									break;
+								}
+								case 4:
+								{
+									context.IncrementDepth();
+									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+									{
+										long mapCount;
+										while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										// If settable
+										//if (attributes == null)
+										//{
+										//	attributes = new Dictionary<string, string>(mapCount); // or 0
+										//}
+										for (var j = 0; j < mapCount; j++)
+										{
+											string key;
+											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+											string value;
+											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											attributes.Add(key, value);
+										}
+									}
+									else
+									{
+										CollectionItemIterator iterator;
+										while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+
+										while (!iterator.CollectionEnds(memory, out requestHint))
+										{
+											if (requestHint != 0)
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											string key;
+											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+											string value;
+											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
+											{
+												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											}
+
+											attributes.Add(key, value);
+										}
+
+										while (!iterator.Drain(ref memory, out requestHint))
+										{
+											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+										}
+									}
+									context.DecrementDepth();
+									break;
+								}
+#endif
+								default:
+								{
+#warning TODO: TrySkip loop
+									break;
+								}
+							}
+						}
+						finally
+						{
+							if (propertyKey != null)
+							{
+								context.ByteBufferPool.Return(propertyKey);
+							}
+						}
+					}
+				}
+
+				if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					itemsCount -= 5;
+					while (!TryDrain(context, ref memory, itemsCount, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+				else
+				{
+					while (!propertyIterator.Drain(ref memory, out requestHint))
+					{
+						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+
+				context.DecrementDepth();
+
+				// Verbose for Deserialize...
+#if STRING
+				obj.Name = name;
+#endif
+#if INT32
+				obj.Age = age;
+#endif
+#if BOOL
+				obj.IsActive = isActive;
+#endif
+				// If settable
+				// obj.Roles = roles;
+				// If settable
+				// obj.Attributes = attributes;
+				return true;
+			}
+			finally
+			{
+				context.ByteBufferPool.Return(buffer, clearArray: true);
+			}
+		}
+	}
+
+	public sealed class SampleInt32ArraySerializer<TExtensionType> : IObjectSerializer<int[], TExtensionType>
+	{
+		public void Serialize(ref SerializationOperationContext<TExtensionType> context, int[] obj, IBufferWriter<byte> sink)
+		{
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			context.Encoder.EncodeArrayStart(obj.Length, sink, context.CollectionContext);
+			for (var i = 0; i < obj.Length; i++)
+			{
+				context.Encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+				context.Encoder.EncodeInt32(obj[i], sink);
+				context.Encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+			}
+			context.Encoder.EncodeArrayEnd(obj.Length, sink, context.CollectionContext);
+		}
+
+		public ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, int[] obj, Stream streamSink)
+		{
+			throw new NotImplementedException();
+		}
+
+		public int[] Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source)
+		{
+			if (context.Decoder.FormatFeatures.CanCountCollectionItems)
+			{
+				var length = context.Decoder.DecodeArrayHeader(ref source);
+				var result = new int[length];
+				for (var i = 0; i < result.Length; i++)
+				{
+					result[i] = context.Decoder.DecodeInt32(ref source);
+				}
+				context.Decoder.Drain(ref source, context.CollectionContext, 0);
+				return result;
+			}
+			else
+			{
+				var result = new List<int>();
+				var iterator = context.Decoder.DecodeArray(ref source);
+				while (!iterator.CollectionEnds(ref source))
+				{
+					result.Add(context.Decoder.DecodeInt32(ref source));
+				}
+				iterator.Drain(ref source);
+				return result.ToArray();
+			}
+		}
+
+		public ValueTask<int[]> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source, in int[] obj)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, int[] obj)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	public sealed class SampleInt32Serializer<TExtensionType> : IObjectSerializer<int, TExtensionType>
+	{
+		public void Serialize(ref SerializationOperationContext<TExtensionType> context, int obj, IBufferWriter<byte> sink)
+		{
+			context.Encoder.EncodeInt32(obj, sink);
+		}
+
+		public ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, int obj, Stream streamSink)
+		{
+			throw new NotImplementedException();
+		}
+
+		public int Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source)
+		{
+			return context.Decoder.DecodeInt32(ref source);
+		}
+
+		public ValueTask<int> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source, in int obj)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, int obj)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}

From 1bd8c5673a7f0d9994bf0bf4a3a0ce3ae1081c1d Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 22 Jun 2020 19:27:57 +0900
Subject: [PATCH 26/82] Fix max size of array, map, string, binary

Limit collection size with CLR/Core CLR limit.
It might be different in Mono, it is not so important because CLR limit is very large enough.
---
 .../{Internal => }/Ensure.cs                  | 18 ++++++++++++-
 .../Internal/DecoderOptionsBuilder.cs         |  6 ++---
 .../Internal/OptionsDefaults.cs               |  3 +++
 .../DeserializationOptionsBuilder.cs          |  8 +++---
 .../SerializationOptionsBuilder.cs            |  2 +-
 .../{Internal => }/Throw.cs                   | 25 ++++++++++++-------
 6 files changed, 44 insertions(+), 18 deletions(-)
 rename src/MsgPack.Abstraction/{Internal => }/Ensure.cs (74%)
 rename src/MsgPack.Abstraction/{Internal => }/Throw.cs (87%)

diff --git a/src/MsgPack.Abstraction/Internal/Ensure.cs b/src/MsgPack.Abstraction/Ensure.cs
similarity index 74%
rename from src/MsgPack.Abstraction/Internal/Ensure.cs
rename to src/MsgPack.Abstraction/Ensure.cs
index 379f8e90f..0f2f62aae 100644
--- a/src/MsgPack.Abstraction/Internal/Ensure.cs
+++ b/src/MsgPack.Abstraction/Ensure.cs
@@ -7,7 +7,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
-namespace MsgPack.Internal
+namespace MsgPack
 {
 	internal static class Ensure
 	{
@@ -54,5 +54,21 @@ public static T IsNotGreaterThan<T>(T value, T maxInclusive, [CallerArgumentExpr
 
 			return value;
 		}
+
+		public static T IsBetween<T>(T value, T minInclusive, T maxInclusive, [CallerArgumentExpression("value")] string paramName = null!)
+			where T : struct, IComparable<T>
+		{
+			if (value.CompareTo(minInclusive) < 0)
+			{
+				Throw.ArgumentOutOfRange(paramName, $"Value cannot be less than {minInclusive}.");
+			}
+
+			if (value.CompareTo(maxInclusive) > 0)
+			{
+				Throw.ArgumentOutOfRange(paramName, $"Value cannot be greater than {maxInclusive}.");
+			}
+
+			return value;
+		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
index 893cff502..c1a7e9ca0 100644
--- a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
@@ -23,7 +23,7 @@ public int CancellationSupportThreshold
 		public int MaxNumberLengthInBytes
 		{
 			get => this._maxNumberLengthInBytes;
-			set => this._maxNumberLengthInBytes = Ensure.IsNotLessThan(value, 1);
+			set => this._maxNumberLengthInBytes = Ensure.IsBetween(value, 1, OptionsDefaults.MaxSingleByteCollectionLength);
 		}
 
 		private int _maxStringLengthInBytes = OptionsDefaults.MaxStringLengthInBytes;
@@ -31,7 +31,7 @@ public int MaxNumberLengthInBytes
 		public int MaxStringLengthInBytes
 	{
 			get => this._maxStringLengthInBytes;
-			set => this._maxStringLengthInBytes = Ensure.IsNotLessThan(value, 1);
+			set => this._maxStringLengthInBytes = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
 		private int _naxBinaryLengthInBytes = OptionsDefaults.MaxBinaryLengthInBytes;
@@ -39,7 +39,7 @@ public int MaxStringLengthInBytes
 		public int MaxBinaryLengthInBytes
 		{
 			get => this._naxBinaryLengthInBytes;
-			set => this._naxBinaryLengthInBytes = Ensure.IsNotLessThan(value, 1);
+			set => this._naxBinaryLengthInBytes = Ensure.IsBetween(value, 1, OptionsDefaults.MaxSingleByteCollectionLength);
 		}
 
 		private int _maxByteBufferLength = OptionsDefaults.MaxByteBufferLength;
diff --git a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
index 7f470ff1f..a8ecbb089 100644
--- a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
+++ b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
@@ -9,6 +9,9 @@ namespace MsgPack.Internal
 #warning TODO: tuning default as backward compatible
 	internal static class OptionsDefaults
 	{
+		public const int MaxSingleByteCollectionLength = 0x7FFFFFC7;
+		public const int MaxMultiByteCollectionLength = 0X7FEFFFFF;
+
 		public static readonly int CancellationSupportThreshold = 128 * 1024 * 1024; // About 0.1 sec in desktop, more for IoT
 		public static readonly int MaxNumberLengthInBytes = 32;
 		public static readonly int MaxStringLengthInBytes = 256 * 1024 * 1024;
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
index 2bba8d676..3b965806f 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
@@ -15,7 +15,7 @@ public sealed class DeserializationOptionsBuilder
 		public int MaxArrayLength
 		{
 			get => this._maxArrayLength;
-			set => this._maxArrayLength = Ensure.IsNotLessThan(value, 0);
+			set => this._maxArrayLength = Ensure.IsBetween(value, 0, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
 		private int _maxMapCount = OptionsDefaults.MaxMapCount;
@@ -23,7 +23,7 @@ public int MaxArrayLength
 		public int MaxMapCount
 		{
 			get => this._maxMapCount;
-			set => this._maxMapCount = Ensure.IsNotLessThan(value, 0);
+			set => this._maxMapCount = Ensure.IsBetween(value, 0, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
 		private int _maxPropertyKeyLength = OptionsDefaults.MaxPropertyKeyLength;
@@ -31,7 +31,7 @@ public int MaxMapCount
 		public int MaxPropertyKeyLength
 		{
 			get => this._maxPropertyKeyLength;
-			set => this._maxPropertyKeyLength = Ensure.IsNotLessThan(value, 1);
+			set => this._maxPropertyKeyLength = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
 		private int _maxDepth = OptionsDefaults.MaxDepth;
@@ -39,7 +39,7 @@ public int MaxPropertyKeyLength
 		public int MaxDepth
 		{
 			get => this._maxDepth;
-			set => this._maxDepth = Ensure.IsNotLessThan(value, 1);
+			set => this._maxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
 		public Encoding? StringEncoding { get; set; }
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
index 90ef1bd8a..0f6475495 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
@@ -13,7 +13,7 @@ public sealed class SerializationOptionsBuilder
 		public int MaxDepth
 		{
 			get => this._maxDepth;
-			set => this._maxDepth = Ensure.IsNotLessThan(value, 1);
+			set => this._maxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
 		public System.Text.Encoding? StringEncoding { get; set; }
diff --git a/src/MsgPack.Abstraction/Internal/Throw.cs b/src/MsgPack.Abstraction/Throw.cs
similarity index 87%
rename from src/MsgPack.Abstraction/Internal/Throw.cs
rename to src/MsgPack.Abstraction/Throw.cs
index 929b3670d..4d67dc451 100644
--- a/src/MsgPack.Abstraction/Internal/Throw.cs
+++ b/src/MsgPack.Abstraction/Throw.cs
@@ -4,8 +4,9 @@
 
 using System;
 using System.Text;
+using MsgPack.Internal;
 
-namespace MsgPack.Internal
+namespace MsgPack
 {
 	internal static class Throw
 	{
@@ -18,8 +19,17 @@ public static void ArgumentOutOfRange(string paramName, string message)
 		public static void ExtensionsIsNotSupported()
 			=> throw new NotSupportedException($"Extension type is not supported in this encoder.");
 
-		public static void TooLargeCharLength(long size)
-			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It is {size:#,0} chars, but it must be lessor than {Int32.MaxValue:#,0} chars. Use EncodeLargeString instead.");
+		public static void StreamMustBeAbleToRead(string paramName)
+			=> throw new ArgumentException($"The stream must be able to read.", paramName);
+
+		public static void TooSmallBuffer(string paramName, int minimumInclusive)
+			=> throw new ArgumentException($"The size of buffer must be greater than or equal to {minimumInclusive:#,0}.", paramName);
+
+		public static void TooLargeLength(int length, int requestHint)
+			=> throw new ArgumentException($"Requested buffer size {((long)length + requestHint):#,0} is too large. It must be less than or equal to {OptionsDefaults.MaxSingleByteCollectionLength:#,0} bytes.");
+
+		public static void EmptyObject(Type type)
+			=> throw new InvalidOperationException($"Cannot use empty '{type}' object.");
 
 		public static void DepthExeeded(long position, int maxDepth)
 			=> throw new LimitExceededException($"The depth of collection exceeds max depth {maxDepth:#,0} at {position:#,0}.");
@@ -34,15 +44,12 @@ public static void DepthUnderflow()
 			=> throw new InvalidOperationException("CurrentDepth is 0.");
 
 		public static void TooLargeByteLength(long size, string encodingName)
-			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to {size:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes. Use EncodeLargeString instead.");
+			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to {size:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes.");
 
 		public static void TooLargeByteLength(Exception innerException, string encodingName)
-			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to larger than {Int32.MaxValue:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes. Use EncodeLargeString instead.", innerException);
-
-		public static void TooLargeByteLengthForString(string encodingName)
-			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be decoded to larger than maximum System.String length with '{encodingName}' encoding.");
+			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to larger than {Int32.MaxValue:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes.", innerException);
 
-		internal static void TooLargePropertyKey(long position, int length, int maxPropertyKeyLength)
+		public static void TooLargePropertyKey(long position, int length, int maxPropertyKeyLength)
 			=> throw new InvalidOperationException($"Property key is too large. The size {length:#,0} is larger than configured limit {maxPropertyKeyLength:#,0} at {position:#,0}.");
 
 		public static void InsufficientInput(long position, Type targetType, int requestHint)

From 204dded3d0ccb67585980c836a52e3f474c3a7f9 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 22 Jun 2020 19:29:40 +0900
Subject: [PATCH 27/82] Code claunup

---
 .../Internal/DecoderOptionsBuilder.cs         |  1 +
 .../Internal/StreamBufferWriter.cs            |  2 +-
 .../Internal/StreamReadOnlyMemoryProvider.cs  | 29 +++++++++++++++----
 .../LimitExceededException.cs                 |  3 +-
 .../MsgPack.Abstraction.csproj                | 23 ++++++++-------
 .../Properties/AssemblyInfo.cs                |  4 ++-
 .../AsyncDeserializationOperationContext`1.cs |  2 +-
 .../AsyncDeserializationOperationContext`1.tt |  0
 .../AsyncSerializationOperationContext`1.cs   |  2 +-
 .../AsyncSerializationOperationContext`1.tt   |  0
 .../DeserializationOperationContext`1.cs      |  2 +-
 .../DeserializationOperationContext`1.tt      |  0
 .../{Internal => }/OperationContext.ttinclude |  2 +-
 .../SerializationOperationContext`1.cs        |  2 +-
 .../SerializationOperationContext`1.tt        |  0
 .../Internal/MessagePackEncoder.Strings.cs    |  4 +--
 16 files changed, 49 insertions(+), 27 deletions(-)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/AsyncDeserializationOperationContext`1.cs (98%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/AsyncDeserializationOperationContext`1.tt (100%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/AsyncSerializationOperationContext`1.cs (97%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/AsyncSerializationOperationContext`1.tt (100%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/DeserializationOperationContext`1.cs (97%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/DeserializationOperationContext`1.tt (100%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/OperationContext.ttinclude (98%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/SerializationOperationContext`1.cs (97%)
 rename src/MsgPack.Abstraction/Serialization/{Internal => }/SerializationOperationContext`1.tt (100%)

diff --git a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
index c1a7e9ca0..be520fadb 100644
--- a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
@@ -6,6 +6,7 @@
 
 namespace MsgPack.Internal
 {
+#warning Remove unused buffer max pr rename to initial buffer length if appropriate.
 	public abstract class DecoderOptionsBuilder
 	{
 		public bool CanTreatRealAsInteger { get; set; } = OptionsDefaults.CanTreatRealAsInteger;
diff --git a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
index ab347a216..5b94e0035 100644
--- a/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
+++ b/src/MsgPack.Abstraction/Internal/StreamBufferWriter.cs
@@ -9,7 +9,7 @@
 
 namespace MsgPack.Internal
 {
-#warning TODO: Pubternal or CodeGen
+#warning TODO: CodeGen
 	public sealed class StreamBufferWriter : IBufferWriter<byte>, IAsyncDisposable
 	{
 		private readonly Stream _underlying;
diff --git a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
index adfd64d77..0934bbbdf 100644
--- a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
+++ b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
@@ -9,25 +9,42 @@
 
 namespace MsgPack.Internal
 {
-#warning TODO: PubTernal or CodeGen
-	public sealed class StreamReadOnlyMemoryProvider
+	public struct StreamReadOnlyMemoryProvider
 	{
 		private readonly Stream _stream;
 		private readonly byte[] _buffer;
 
 		public StreamReadOnlyMemoryProvider(Stream stream, byte[] buffer)
 		{
+			Ensure.NotNull(stream);
+			if (!stream.CanRead)
+			{
+				Throw.StreamMustBeAbleToRead(nameof(stream));
+			}
+
+			Ensure.NotNull(buffer);
+			if (buffer.Length == 0)
+			{
+				Throw.TooSmallBuffer(nameof(buffer), 1);
+			}
+
 			this._stream = stream;
 			this._buffer = buffer;
 		}
 
 		public async ValueTask<ReadOnlyMemory<byte>> GetNextAsync(ReadOnlyMemory<byte> previous, int requestHint, CancellationToken cancellationToken)
 		{
+			if (this._stream is null)
+			{
+				Throw.EmptyObject(typeof(StreamReadOnlyMemoryProvider));
+				// never
+				return default;
+			}
+
 			var required = (long)previous.Length + requestHint;
-			if (required > UInt32.MaxValue)
+			if (required > OptionsDefaults.MaxSingleByteCollectionLength)
 			{
-#warning TODO:
-				throw new Exception("Too large");
+				Throw.TooLargeLength(previous.Length, requestHint);
 			}
 
 			Memory<byte> buffer;
@@ -37,7 +54,7 @@ public async ValueTask<ReadOnlyMemory<byte>> GetNextAsync(ReadOnlyMemory<byte> p
 				{
 					this._buffer.AsSpan().CopyTo(this._buffer.AsSpan(previous.Length));
 				}
-				
+
 				buffer = this._buffer.AsMemory(previous.Length);
 				if (requestHint > 0)
 				{
diff --git a/src/MsgPack.Abstraction/LimitExceededException.cs b/src/MsgPack.Abstraction/LimitExceededException.cs
index a49484da8..19ef6a106 100644
--- a/src/MsgPack.Abstraction/LimitExceededException.cs
+++ b/src/MsgPack.Abstraction/LimitExceededException.cs
@@ -6,11 +6,10 @@
 
 namespace MsgPack
 {
-#warning TODO: Quota? Limit?
 	public sealed class LimitExceededException : Exception
 	{
 		public LimitExceededException()
-			: this("Sime quota is exeeded.") { }
+			: this("Some limit is exeeded.") { }
 
 		public LimitExceededException(string? message)
 			: base(message) { }
diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
index 19123fb42..08f97e67a 100644
--- a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -7,6 +7,9 @@
   <ItemGroup>
     <Compile Include="../MsgPack/MessageNotSupportedException.cs" Link="MessageNotSupportedException.cs" />
     <Compile Include="../MsgPack/MessageTypeException.cs" Link="MessageTypeException.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.cs" Link="Serialization\PolymorphismSchema.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.Internals.cs" Link="Serialization\PolymorphismSchema.Internals.cs" />
+    <Compile Include="..\MsgPack\Serialization\SerializerCapabilities.cs" Link="Serialization\SerializerCapabilities.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -22,19 +25,19 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Decoder`1.Primitives.cs</LastGenOutput>
     </None>
-    <None Update="Serialization\Internal\AsyncSerializationOperationContext`1.tt">
+    <None Update="Serialization\AsyncSerializationOperationContext`1.tt">
       <LastGenOutput>AsyncSerializationOperationContext`1.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Serialization\Internal\AsyncDeserializationOperationContext`1.tt">
+    <None Update="Serialization\AsyncDeserializationOperationContext`1.tt">
       <LastGenOutput>AsyncDeserializationOperationContext`1.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Serialization\Internal\DeserializationOperationContext`1.tt">
+    <None Update="Serialization\DeserializationOperationContext`1.tt">
       <LastGenOutput>DeserializationOperationContext`1.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Serialization\Internal\SerializationOperationContext`1.tt">
+    <None Update="Serialization\SerializationOperationContext`1.tt">
       <LastGenOutput>SerializationOperationContext`1.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
@@ -60,25 +63,25 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Encoder`1.Primitives.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\Internal\AsyncDeserializationOperationContext`1.cs">
+    <Compile Update="Serialization\AsyncDeserializationOperationContext`1.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
       <DependentUpon>AsyncDeserializationOperationContext`1.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\Internal\AsyncSerializationOperationContext`1.cs">
+    <Compile Update="Serialization\AsyncSerializationOperationContext`1.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
       <DependentUpon>AsyncSerializationOperationContext`1.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\Internal\DeserializationOperationContext`1.cs">
-      <DependentUpon>DeserializationOperationContext`1.tt</DependentUpon>
+    <Compile Update="Serialization\DeserializationOperationContext`1.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
+      <DependentUpon>DeserializationOperationContext`1.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\Internal\SerializationOperationContext`1.cs">
-      <DependentUpon>SerializationOperationContext`1.tt</DependentUpon>
+    <Compile Update="Serialization\SerializationOperationContext`1.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
+      <DependentUpon>SerializationOperationContext`1.tt</DependentUpon>
     </Compile>
   </ItemGroup>
   
diff --git a/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs b/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs
index 4c671542f..430590546 100644
--- a/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs
+++ b/src/MsgPack.Abstraction/Properties/AssemblyInfo.cs
@@ -1,4 +1,6 @@
-#warning TODO:HEADER
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System.Runtime.CompilerServices;
 
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.cs
similarity index 98%
rename from src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.cs
index 58b091d48..53025b8c9 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.cs
@@ -14,7 +14,7 @@
 using System.Threading;
 using MsgPack.Internal;
 
-namespace MsgPack.Serialization.Internal
+namespace MsgPack.Serialization
 {
 	public sealed class AsyncDeserializationOperationContext<TExtensionType>
 	{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/Internal/AsyncDeserializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.tt
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.cs
similarity index 97%
rename from src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.cs
index 2c358a124..6fb561b90 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.cs
@@ -13,7 +13,7 @@
 using System.Threading;
 using MsgPack.Internal;
 
-namespace MsgPack.Serialization.Internal
+namespace MsgPack.Serialization
 {
 	public sealed class AsyncSerializationOperationContext<TExtensionType>
 	{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/Internal/AsyncSerializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.tt
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.cs
similarity index 97%
rename from src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.cs
index fe2014917..b0b762a74 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.cs
@@ -14,7 +14,7 @@
 using System.Threading;
 using MsgPack.Internal;
 
-namespace MsgPack.Serialization.Internal
+namespace MsgPack.Serialization
 {
 	public struct DeserializationOperationContext<TExtensionType>
 	{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/Internal/DeserializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.tt
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
similarity index 98%
rename from src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude
rename to src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
index 5cdba01ee..8d886708e 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/OperationContext.ttinclude
+++ b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
@@ -30,7 +30,7 @@ using System.Text;
 using System.Threading;
 using MsgPack.Internal;
 
-namespace MsgPack.Serialization.Internal
+namespace MsgPack.Serialization
 {
 	public <#= typeClass #> <#= typeName #><TExtensionType>
 	{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.cs
similarity index 97%
rename from src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.cs
index b1f829e15..36f7ca1fc 100644
--- a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.cs
@@ -13,7 +13,7 @@
 using System.Threading;
 using MsgPack.Internal;
 
-namespace MsgPack.Serialization.Internal
+namespace MsgPack.Serialization
 {
 	public struct SerializationOperationContext<TExtensionType>
 	{
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/Internal/SerializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.tt
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
index c5b737a4c..5af1509be 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.Strings.cs
@@ -95,7 +95,7 @@ private void EncodeStringSlow(ReadOnlySpan<char> value, IBufferWriter<byte> buff
 					try
 					{
 						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
-						buffer.Write(encodingBuffer.AsSpan(0, totalLength));
+						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
 					}
 					finally
 					{
@@ -221,7 +221,7 @@ private void EncodeStringSlow(in ReadOnlySequence<char> value, IBufferWriter<byt
 					try
 					{
 						var totalLength = this.EncodeLargeString1Path(value, buffer, encoding, estimatedLength, encodingBuffer);
-						buffer.Write(encodingBuffer.AsSpan(0, totalLength));
+						buffer.Write(encodingBuffer.AsMemory(0, totalLength).Span);
 					}
 					finally
 					{

From 66ac07d44ff8ac0750c219f7b86c8a24cdc9e4c9 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 22 Jun 2020 19:30:47 +0900
Subject: [PATCH 28/82] Add initial serializer generator layer

* This commit also remove TExtensions generic parameter for better polymorphism.
---
 Directory.Build.props                         |  15 +-
 doc/v2.md                                     |  13 +-
 src/MsgPack.Abstraction/ExtensionType.cs      | 117 +++
 .../ExtensionTypeObject.cs                    |  41 +
 ...odeItemResult`1.cs => DecodeItemResult.cs} |  40 +-
 ...mitives.cs => FormatDecoder.Primitives.cs} |   2 +-
 ...mitives.tt => FormatDecoder.Primitives.tt} |   2 +-
 ...`1.Strings.cs => FormatDecoder.Strings.cs} |   2 +-
 ...`1.Strings.tt => FormatDecoder.Strings.tt} |   2 +-
 .../{Decoder`1.cs => FormatDecoder.cs}        |  18 +-
 ...oderOptions.cs => FormatDecoderOptions.cs} |   4 +-
 ...lder.cs => FormatDecoderOptionsBuilder.cs} |   8 +-
 ...mitives.cs => FormatEncoder.Primitives.cs} |   2 +-
 ...mitives.tt => FormatEncoder.Primitives.tt} |   2 +-
 .../{Encoder`1.cs => FormatEncoder.cs}        |  15 +-
 ...oderOptions.cs => FormatEncoderOptions.cs} |   4 +-
 ...lder.cs => FormatEncoderOptionsBuilder.cs} |   6 +-
 .../Internal/FormatFeatures.cs                |  22 +-
 .../Internal/NullExtensionType.cs             |  11 -
 .../MsgPack.Abstraction.csproj                |  58 +-
 ...> AsyncDeserializationOperationContext.cs} |  10 +-
 ...> AsyncDeserializationOperationContext.tt} |   0
 ... => AsyncSerializationOperationContext.cs} |  10 +-
 ... => AsyncSerializationOperationContext.tt} |   0
 ....cs => DeserializationOperationContext.cs} |   6 +-
 ....tt => DeserializationOperationContext.tt} |   0
 .../Internal/IObjectSerializer`2.cs           |  20 -
 .../ObjectSerializationContext.cs             |  17 +
 .../Serialization/ObjectSerializer`1.cs       |  43 +
 .../Serialization/OperationContext.ttinclude  |  15 +-
 ...`1.cs => SerializationOperationContext.cs} |   6 +-
 ...`1.tt => SerializationOperationContext.tt} |   0
 .../Serialization/Serializer.cs               |  29 +
 .../Serialization/Serializer`2.cs             |  66 +-
 .../Internal/CurrentMessagePackEncoder.cs     |  13 +-
 .../Internal/MessagePackDecoder.DecodeItem.cs |  26 +-
 .../Internal/MessagePackDecoder.Extension.cs  |  15 +-
 .../Internal/MessagePackDecoder.cs            |   2 +-
 .../Internal/MessagePackDecoderOptions.cs     |   2 +-
 .../MessagePackDecoderOptionsBuilder.cs       |   2 +-
 .../Internal/MessagePackEncoder.cs            |   4 +-
 .../Internal/MessagePackEncoderOptions.cs     |   2 +-
 .../MessagePackEncoderOptionsBuilder.cs       |   2 +-
 .../Internal/MessagePackExtensionType.cs      |  43 -
 src/MsgPack.Core/Internal/MessagePackThrow.cs |   3 +
 .../Json/JsonDecoder.DecodeItem.cs            |   2 -
 src/MsgPack.Json/Json/JsonDecoder.cs          |   2 +-
 src/MsgPack.Json/Json/JsonDecoderOptions.cs   |   2 +-
 .../Json/JsonDecoderOptionsBuilder.cs         |   2 +-
 src/MsgPack.Json/Json/JsonEncoder.cs          |   2 +-
 src/MsgPack.Json/Json/JsonEncoderOptions.cs   |   2 +-
 .../Json/JsonEncoderOptionsBuilder.cs         |   4 +-
 .../MsgPack.Serialization.ILGeneration.csproj |  18 +
 .../MsgPack.Serialization.Reflection.csproj   |   5 +
 .../ReflectionSerializer`2.cs                 | 126 +++
 .../MsgPack.Serialization.csproj              |  63 ++
 .../Properties/AssemblyInfo.cs                |  13 +
 .../MessagePackNullableAttribute.cs           |  19 +
 .../Reflection/EncoderMethods.cs              |  76 ++
 .../Serialization/Reflection/SpanMethods.cs   |  37 +
 .../Serialization/SerializerBuilder.cs        |  11 +
 .../SerializerGenerationOptions.cs            |  60 ++
 .../Serialization/Throw.Internal.cs           | 125 +++
 .../Serialization/Throw.cs                    |  34 +
 .../Serialization/Throw.tt                    |  10 +
 .../Serialization/Throw.ttinclude             |  41 +
 src/MsgPack.Serialization/Utf8String.cs       |  40 +
 src/MsgPack/Serialization/BindingOptions.cs   |  47 +-
 .../Serialization/CollectionDetailedKind.cs   |  43 +-
 src/MsgPack/Serialization/CollectionKind.cs   |  35 +-
 .../Serialization/CollectionTraitOptions.cs   |  31 +-
 src/MsgPack/Serialization/CollectionTraits.cs |  86 +-
 .../Serialization/DataMemberContract.cs       | 131 +--
 .../Serialization/DateTimeConversionMethod.cs |  22 +-
 .../DateTimeMemberConversionMethod.cs         |  22 +-
 .../EnumMemberSerializationMethod.cs          |  26 +-
 .../Serialization/EnumSerializationMethod.cs  |  26 +-
 .../Serialization/EnumSerializationOptions.cs |  14 +-
 .../MessagePackDateTimeMemberAttribute.cs     |  26 +-
 ...PackDeserializationConstructorAttribute.cs |  24 +-
 .../Serialization/MessagePackEnumAttribute.cs |  26 +-
 .../MessagePackEnumMemberAttribute.cs         |  26 +-
 .../MessagePackIgnoreAttribute.cs             |  24 +-
 .../MessagePackMemberAttribute.cs             |  52 +-
 src/MsgPack/Serialization/NilImplication.cs   |  22 +-
 .../Polymorphic/IPolymorphicDeserializer.cs   |  19 +-
 .../PolymorphismSchema.Internals.cs           | 425 +++++----
 .../ReflectionExtensions.CollectionTraits.cs  | 661 ++++++-------
 ...eflectionExtensions.ConstructorDelegate.cs |  54 +-
 .../Serialization/ReflectionExtensions.cs     | 105 ++-
 .../Serialization/SerializationExceptions.cs  | 367 ++++----
 .../SerializationMethodGeneratorOption.cs     |  35 +-
 .../Serialization/SerializationTarget.cs      | 867 +++++++-----------
 .../Serialization/SerializerCapabilities.cs   |  47 +-
 .../Serialization/SerializerOptions.cs        |  71 +-
 .../Serialization/SerializingMember.cs        | 129 +--
 src/MsgPack/TupleItems.cs                     | 111 ++-
 .../Serializers/MsgPackCliSerializer.cs       |  28 +-
 test/Benchmark/_SampleObject.cs               | 816 ++++++++---------
 99 files changed, 3068 insertions(+), 2764 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/ExtensionType.cs
 create mode 100644 src/MsgPack.Abstraction/ExtensionTypeObject.cs
 rename src/MsgPack.Abstraction/Internal/{DecodeItemResult`1.cs => DecodeItemResult.cs} (50%)
 rename src/MsgPack.Abstraction/Internal/{Decoder`1.Primitives.cs => FormatDecoder.Primitives.cs} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder`1.Primitives.tt => FormatDecoder.Primitives.tt} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder`1.Strings.cs => FormatDecoder.Strings.cs} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder`1.Strings.tt => FormatDecoder.Strings.tt} (99%)
 rename src/MsgPack.Abstraction/Internal/{Decoder`1.cs => FormatDecoder.cs} (94%)
 rename src/MsgPack.Abstraction/Internal/{DecoderOptions.cs => FormatDecoderOptions.cs} (92%)
 rename src/MsgPack.Abstraction/Internal/{DecoderOptionsBuilder.cs => FormatDecoderOptionsBuilder.cs} (92%)
 rename src/MsgPack.Abstraction/Internal/{Encoder`1.Primitives.cs => FormatEncoder.Primitives.cs} (99%)
 rename src/MsgPack.Abstraction/Internal/{Encoder`1.Primitives.tt => FormatEncoder.Primitives.tt} (98%)
 rename src/MsgPack.Abstraction/Internal/{Encoder`1.cs => FormatEncoder.cs} (90%)
 rename src/MsgPack.Abstraction/Internal/{EncoderOptions.cs => FormatEncoderOptions.cs} (88%)
 rename src/MsgPack.Abstraction/Internal/{EncoderOptionsBuilder.cs => FormatEncoderOptionsBuilder.cs} (90%)
 delete mode 100644 src/MsgPack.Abstraction/Internal/NullExtensionType.cs
 rename src/MsgPack.Abstraction/Serialization/{AsyncDeserializationOperationContext`1.cs => AsyncDeserializationOperationContext.cs} (77%)
 rename src/MsgPack.Abstraction/Serialization/{AsyncDeserializationOperationContext`1.tt => AsyncDeserializationOperationContext.tt} (100%)
 rename src/MsgPack.Abstraction/Serialization/{AsyncSerializationOperationContext`1.cs => AsyncSerializationOperationContext.cs} (73%)
 rename src/MsgPack.Abstraction/Serialization/{AsyncSerializationOperationContext`1.tt => AsyncSerializationOperationContext.tt} (100%)
 rename src/MsgPack.Abstraction/Serialization/{DeserializationOperationContext`1.cs => DeserializationOperationContext.cs} (86%)
 rename src/MsgPack.Abstraction/Serialization/{DeserializationOperationContext`1.tt => DeserializationOperationContext.tt} (100%)
 delete mode 100644 src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
 rename src/MsgPack.Abstraction/Serialization/{SerializationOperationContext`1.cs => SerializationOperationContext.cs} (84%)
 rename src/MsgPack.Abstraction/Serialization/{SerializationOperationContext`1.tt => SerializationOperationContext.tt} (100%)
 create mode 100644 src/MsgPack.Abstraction/Serialization/Serializer.cs
 delete mode 100644 src/MsgPack.Core/Internal/MessagePackExtensionType.cs
 create mode 100644 src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs
 create mode 100644 src/MsgPack.Serialization/Properties/AssemblyInfo.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/MessagePackNullableAttribute.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Reflection/EncoderMethods.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Reflection/SpanMethods.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Throw.Internal.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Throw.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Throw.tt
 create mode 100644 src/MsgPack.Serialization/Serialization/Throw.ttinclude
 create mode 100644 src/MsgPack.Serialization/Utf8String.cs

diff --git a/Directory.Build.props b/Directory.Build.props
index 58a34002b..750f3f75c 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -4,12 +4,25 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
+    <RootNamespace>MsgPack</RootNamespace>
     <Nullable>enable</Nullable>
   </PropertyGroup>
+  <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
+    <DefineConstants>$(DefineConstants);UNITY;AOT</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="!$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
+    <DefineConstants>$(DefineConstants);LIBRARY</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' != 'net35'">
+    <DefineConstants>$(DefineConstants);FEATURE_READ_ONLY_COLLECTION;FEATURE_TAP</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.1'">
+    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE</DefineConstants>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
     <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(TargetFramework)' == 'net6'">
+  <PropertyGroup Condition="('$(TargetFramework)' == 'net5') or ('$(TargetFramework)' == 'net6')">
     <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ENCODING_EXTENSION;FEATURE_UTF8STRING</DefineConstants>
   </PropertyGroup>
 </Project>
diff --git a/doc/v2.md b/doc/v2.md
index 7f1c3ddd7..655032d4e 100644
--- a/doc/v2.md
+++ b/doc/v2.md
@@ -5,6 +5,15 @@ Goals
 ---
 
 * Supports .NET Framework 3.5 and 4.8, .NET Core 2.1 and 3.1, Xamarin Android and iOS, UWP, Unity.
+  * Supproted TFM:
+    * [ ] `net35`
+    * [ ] `netstandard1.4` (for .NET 4.8)
+    * [ ] `netstandard2.0` (for .NET Core 2.1)
+    * [ ] `netstandard2.1` (for .NET Core 3.1 and after)
+    * [ ] `MonoAndroid10` (for Xamarin Android AOT)
+    * [ ] `Xamarin.iOS10` (for Xamarin iOS AOT)
+    * [ ] `uap` (for .NET Native)
+    * [ ] (N/A) (for Unity IL2CPP)
 * Supports stream based serialization/deserialization for large blobs like v1.
 * Supports various format as possible including JSON, CBOF, protbuf, etc.
 * Keep high level API compatiblity with v1.
@@ -24,8 +33,8 @@ Non-Goals
 Status
 ---
 
-* [ ] Encoder/Decoder layer utlizing `ReadOnlySequence<byte>` and `IBufferWriter<byte>`
-* [ ] Simple JSON serializer with some tweak points for design verification. \[in progress]
+* [x] Encoder/Decoder layer utlizing `ReadOnlySequence<byte>` and `IBufferWriter<byte>`
+* [x] Simple JSON serializer with some tweak points for design verification.
 * [ ] Debugging features
 * [ ] Reflection based object serializer
 * [ ] Code generator w/ CodDOM or Roslyn
diff --git a/src/MsgPack.Abstraction/ExtensionType.cs b/src/MsgPack.Abstraction/ExtensionType.cs
new file mode 100644
index 000000000..1dd4e92b7
--- /dev/null
+++ b/src/MsgPack.Abstraction/ExtensionType.cs
@@ -0,0 +1,117 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.ComponentModel;
+
+namespace MsgPack
+{
+	/// <summary>
+	///		Represents a type of extension.
+	/// </summary>
+	public readonly struct ExtensionType : IComparable<ExtensionType>, IEquatable<ExtensionType>
+	{
+		/// <summary>
+		///		Gets raw tag data.
+		/// </summary>
+		/// <value>Raw tag data. Note that the codec might not allow full <see cref="UInt64"/> length.</value>
+		/// <remarks>
+		///		Valid range and sementics depend on serialization codec.
+		/// </remarks>
+		public ulong Tag { get; }
+
+		/// <summary>
+		///		Initializes new instance.
+		///		This constructor should not be called from application directly.
+		/// </summary>
+		/// <param name="tag">Raw tag data.</param>
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public ExtensionType(ulong tag)
+		{
+			this.Tag = tag;
+		}
+
+		/// <inheritdoc />
+		public bool Equals(ExtensionType other)
+			=> this.Tag == other.Tag;
+
+		/// <inheritdoc />
+		public int CompareTo(ExtensionType other)
+			=> this.Tag.CompareTo(other.Tag);
+
+		/// <inheritdoc />
+		public override bool Equals(object? obj)
+			=> (obj is ExtensionType other) ? this.Equals(other) : false;
+
+		/// <inheritdoc />
+		public override int GetHashCode()
+			=> this.Tag.GetHashCode();
+
+		/// <summary>
+		///		Determines whether two specified instances of <see cref="ExtensionType"/> are equal.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> and <paramref name="right"/> represent the same type; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator ==(ExtensionType left, ExtensionType right)
+			=> left.Tag == right.Tag;
+
+		/// <summary>
+		///		Determines whether two specified instances of <see cref="ExtensionType"/> are not equal.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> and <paramref name="right"/> represent the different type; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator !=(ExtensionType left, ExtensionType right)
+			=> left.Tag != right.Tag;
+
+		/// <summary>
+		///		Determines whether one specified <see cref="ExtensionType"/> object is less than a second specified <see cref="ExtensionType"/> object.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> is less than <paramref name="right"/> in their tag; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator <(ExtensionType left, ExtensionType right)
+			=> left.Tag < right.Tag;
+
+		/// <summary>
+		///		Determines whether one specified <see cref="ExtensionType"/> object is greater than a second specified <see cref="ExtensionType"/> object.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> is greater than <paramref name="right"/> in their tag; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator >(ExtensionType left, ExtensionType right)
+			=> left.Tag > right.Tag;
+
+		/// <summary>
+		///		Determines whether one specified <see cref="ExtensionType"/> object is less than or equal to a second specified <see cref="ExtensionType"/> object.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> is less than or equal to <paramref name="right"/> in their tag; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator <=(ExtensionType left, ExtensionType right)
+			=> left.Tag <= right.Tag;
+
+		/// <summary>
+		///		Determines whether one specified <see cref="ExtensionType"/> object is greater than or equal to a second specified <see cref="ExtensionType"/> object.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> is greater than or equal to <paramref name="right"/> in their tag; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator >=(ExtensionType left, ExtensionType right)
+			=> left.Tag >= right.Tag;
+	}
+}
diff --git a/src/MsgPack.Abstraction/ExtensionTypeObject.cs b/src/MsgPack.Abstraction/ExtensionTypeObject.cs
new file mode 100644
index 000000000..e3b0b0962
--- /dev/null
+++ b/src/MsgPack.Abstraction/ExtensionTypeObject.cs
@@ -0,0 +1,41 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+
+namespace MsgPack
+{
+	/// <summary>
+	///		Represents extension type object data.
+	/// </summary>
+	/// <remarks>
+	///		Valid range and sementics of <see cref="Type"/> depend on serialization codec.
+	///		In addition, some codec does not support extension type at all.
+	/// </remarks>
+	public readonly struct ExtensionTypeObject
+	{
+		/// <summary>
+		///		Gets a type of this extension type data.
+		/// </summary>
+		/// <value>Codec specific type of this extension type data.</value>
+		public ExtensionType Type { get; }
+
+		/// <summary>
+		///		Gets byte sequence which is body of this extension type data.
+		/// </summary>
+		/// <value>Byte sequence which is body of this extension type data.</value>
+		public ReadOnlySequence<byte> Body { get; }
+
+		/// <summary>
+		///		Initializes a new instance.
+		/// </summary>
+		/// <param name="type">Codec specific type of this extension type data.</param>
+		/// <param name="body">Byte sequence which is body of this extension type data.</param>
+		public ExtensionTypeObject(ExtensionType type, ReadOnlySequence<byte> body)
+		{
+			this.Type = type;
+			this.Body = body;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs b/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
similarity index 50%
rename from src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
rename to src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
index 42749053b..1f1ef3a51 100644
--- a/src/MsgPack.Abstraction/Internal/DecodeItemResult`1.cs
+++ b/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
@@ -9,16 +9,16 @@
 namespace MsgPack.Internal
 {
 	/// <summary>
-	///		Represents a result of <see cref="Decoder.DecodeItem"/>.
+	///		Represents a result of <see cref="FormatDecoder.DecodeItem"/>.
 	/// </summary>
-	public readonly struct DecodeItemResult<TExtensionType>
+	public readonly struct DecodeItemResult
 	{
 		public bool HasValue => this.ElementType != ElementType.None;
 		public ElementType ElementType { get; }
 		public ReadOnlySequence<byte> Value { get; }
 		public CollectionItemIterator CollectionIterator { get; }
 		public long CollectionLength { get; }
-		public TExtensionType ExtensionType { get; }
+		public ExtensionTypeObject ExtensionTypeObject { get; }
 		public ReadOnlySequence<byte> ExtensionBody => this.Value;
 		public long RequestHint { get; }
 
@@ -27,7 +27,7 @@ private DecodeItemResult(
 			in ReadOnlySequence<byte> value = default,
 			in CollectionItemIterator collectionIterator = default,
 			long collectionLength = default,
-			TExtensionType extensionType = default,
+			ExtensionTypeObject extensionTypeObject = default,
 			long requestHint = default
 		)
 		{
@@ -35,40 +35,40 @@ private DecodeItemResult(
 			this.Value = value;
 			this.CollectionIterator = collectionIterator;
 			this.CollectionLength = collectionLength;
-			this.ExtensionType = extensionType;
+			this.ExtensionTypeObject = extensionTypeObject;
 			this.RequestHint = requestHint;
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> CollectionHeader(ElementType elementType, in CollectionItemIterator iterator, long length = -1)
-			=> new DecodeItemResult<TExtensionType>(elementType, collectionIterator: iterator, collectionLength: length);
+		public static DecodeItemResult CollectionHeader(ElementType elementType, in CollectionItemIterator iterator, long length = -1)
+			=> new DecodeItemResult(elementType, collectionIterator: iterator, collectionLength: length);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> ScalarOrSequence(ElementType elementType, ReadOnlyMemory<byte> value)
+		public static DecodeItemResult ScalarOrSequence(ElementType elementType, ReadOnlyMemory<byte> value)
 			=> ScalarOrSequence(elementType, new ReadOnlySequence<byte>(value));
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> ScalarOrSequence(ElementType elementType, in ReadOnlySequence<byte> value)
-			=> new DecodeItemResult<TExtensionType>(elementType, value: value);
+		public static DecodeItemResult ScalarOrSequence(ElementType elementType, in ReadOnlySequence<byte> value)
+			=> new DecodeItemResult(elementType, value: value);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> Null()
-			=> new DecodeItemResult<TExtensionType>(ElementType.Null);
+		public static DecodeItemResult Null()
+			=> new DecodeItemResult(ElementType.Null);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> True()
-			=> new DecodeItemResult<TExtensionType>(ElementType.True);
+		public static DecodeItemResult True()
+			=> new DecodeItemResult(ElementType.True);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> False()
-			=> new DecodeItemResult<TExtensionType>(ElementType.False);
+		public static DecodeItemResult False()
+			=> new DecodeItemResult(ElementType.False);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> ExtensionTypeObject(TExtensionType extensionType, in ReadOnlySequence<byte> body)
-			=> new DecodeItemResult<TExtensionType>(ElementType.Extension, extensionType : extensionType, value : body);
+		public static DecodeItemResult ExtensionType(ExtensionTypeObject extensionTypeObject)
+			=> new DecodeItemResult(ElementType.Extension, extensionTypeObject : extensionTypeObject);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult<TExtensionType> InsufficientInput(long requestHint)
-			=> new DecodeItemResult<TExtensionType>(ElementType.None, requestHint: requestHint);
+		public static DecodeItemResult InsufficientInput(long requestHint)
+			=> new DecodeItemResult(ElementType.None, requestHint: requestHint);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
rename to src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs
index 7765926f1..55630e381 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs
@@ -12,7 +12,7 @@
 
 namespace MsgPack.Internal
 {
-	partial class Decoder<TExtensionType>
+	partial class FormatDecoder
 	{
 		/// <summary>
 		///		Decodes <see cref="Byte" /> value from specified sequence.
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
rename to src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt
index 0544c21c5..3eb211dcd 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt
@@ -14,7 +14,7 @@ using System.Runtime.CompilerServices;
 
 namespace MsgPack.Internal
 {
-	partial class Decoder<TExtensionType>
+	partial class FormatDecoder
 	{
 <#
 foreach (var outputType in new [] {
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
rename to src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
index f9aeb3571..0bdc088f8 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
@@ -16,7 +16,7 @@
 
 namespace MsgPack.Internal
 {
-	partial class Decoder<TExtensionType>
+	partial class FormatDecoder
 	{
 		/// <summary>
 		///		Decodes <see cref="String" /> value from specified sequence.
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
rename to src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
index f731b08a9..5f4feaaf5 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.Strings.tt
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
@@ -18,7 +18,7 @@ using System.Threading;
 
 namespace MsgPack.Internal
 {
-	partial class Decoder<TExtensionType>
+	partial class FormatDecoder
 	{
 <#
 foreach (var spec in new [] {
diff --git a/src/MsgPack.Abstraction/Internal/Decoder`1.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
similarity index 94%
rename from src/MsgPack.Abstraction/Internal/Decoder`1.cs
rename to src/MsgPack.Abstraction/Internal/FormatDecoder.cs
index 271fd0ee9..20e0b154e 100644
--- a/src/MsgPack.Abstraction/Internal/Decoder`1.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
@@ -12,19 +12,18 @@ namespace MsgPack.Internal
 #warning TODO: Use 'Try' prefix for published APIs which can return 'requestHint'.
 
 	/// <summary>
-	///		Defines an interface and basic functionarity of stateless <see cref="Decoder"/>.
+	///		Defines an interface and basic functionarity of stateless <see cref="FormatDecoder"/>.
 	/// </summary>
-	/// <typeparam name="TExtensionType">A type of extension type.</typeparam>
 	/// <remarks>
-	///		The <see cref="Decoder"/> is stateless, so caller (serializer, writer, etc.) can cache the instance for performance.
+	///		The <see cref="FormatDecoder"/> is stateless, so caller (serializer, writer, etc.) can cache the instance for performance.
 	/// </remarks>
-	public abstract partial class Decoder<TExtensionType>
+	public abstract partial class FormatDecoder
 	{
 		public FormatFeatures FormatFeatures { get; }
 
-		public DecoderOptions Options { get; }
+		public FormatDecoderOptions Options { get; }
 
-		protected Decoder(DecoderOptions options, FormatFeatures formatFeatures)
+		protected FormatDecoder(FormatDecoderOptions options, FormatFeatures formatFeatures)
 		{
 			this.Options = Ensure.NotNull(options);
 			this.FormatFeatures = Ensure.NotNull(formatFeatures);
@@ -42,7 +41,7 @@ public void Skip(ref SequenceReader<byte> source, in CollectionContext collectio
 
 		public abstract void Skip(ref SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default);
 
-		public abstract bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult<TExtensionType> result, CancellationToken cancellationToken = default);
+		public abstract bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void GetRawString(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, CancellationToken cancellationToken = default)
@@ -188,13 +187,12 @@ public long DecodeMapHeader(ref SequenceReader<byte> source)
 		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
 		public abstract long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint);
 
-		public virtual void DecodeExtension(ref SequenceReader<byte> source, out TExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		public virtual void DecodeExtension(ref SequenceReader<byte> source, out ExtensionTypeObject result, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			Throw.ExtensionsIsNotSupported();
 			// never
-			body = default;
+			result = default;
 			requestHint = -1;
-			typeCode = default!;
 		}
 
 		public CollectionType DecodeArrayOrMap(ref SequenceReader<byte> source, out CollectionItemIterator iterator)
diff --git a/src/MsgPack.Abstraction/Internal/DecoderOptions.cs b/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
similarity index 92%
rename from src/MsgPack.Abstraction/Internal/DecoderOptions.cs
rename to src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
index 9e333bc2c..ef55e0238 100644
--- a/src/MsgPack.Abstraction/Internal/DecoderOptions.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
@@ -6,7 +6,7 @@
 
 namespace MsgPack.Internal
 {
-	public abstract class DecoderOptions
+	public abstract class FormatDecoderOptions
 	{
 		public bool CanTreatRealAsInteger { get; }
 
@@ -28,7 +28,7 @@ public abstract class DecoderOptions
 
 		public bool ClearsBuffer { get; }
 
-		protected DecoderOptions(DecoderOptionsBuilder builder)
+		protected FormatDecoderOptions(FormatDecoderOptionsBuilder builder)
 		{
 			builder = Ensure.NotNull(builder);
 
diff --git a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs
similarity index 92%
rename from src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
rename to src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs
index be520fadb..766108071 100644
--- a/src/MsgPack.Abstraction/Internal/DecoderOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs
@@ -7,7 +7,7 @@
 namespace MsgPack.Internal
 {
 #warning Remove unused buffer max pr rename to initial buffer length if appropriate.
-	public abstract class DecoderOptionsBuilder
+	public abstract class FormatDecoderOptionsBuilder
 	{
 		public bool CanTreatRealAsInteger { get; set; } = OptionsDefaults.CanTreatRealAsInteger;
 
@@ -77,15 +77,15 @@ public ArrayPool<char> CharBufferPool
 
 		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
 
-		protected DecoderOptionsBuilder() { }
+		protected FormatDecoderOptionsBuilder() { }
 
-		public DecoderOptionsBuilder WithoutBufferClear()
+		public FormatDecoderOptionsBuilder WithoutBufferClear()
 		{
 			this.ClearsBuffer = false;
 			return this;
 		}
 
-		public DecoderOptionsBuilder ProhibitTreatRealAsInteger()
+		public FormatDecoderOptionsBuilder ProhibitTreatRealAsInteger()
 		{
 			this.CanTreatRealAsInteger = false;
 			return this;
diff --git a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs b/src/MsgPack.Abstraction/Internal/FormatEncoder.Primitives.cs
similarity index 99%
rename from src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
rename to src/MsgPack.Abstraction/Internal/FormatEncoder.Primitives.cs
index bea877506..0c4701a06 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoder.Primitives.cs
@@ -12,7 +12,7 @@
 
 namespace MsgPack.Internal
 {
-	partial class Encoder<TExtensionType>
+	partial class FormatEncoder
 	{
 		/// <summary>
 		///		Encodes <see cref="Int32" /> value to specified buffer.
diff --git a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt b/src/MsgPack.Abstraction/Internal/FormatEncoder.Primitives.tt
similarity index 98%
rename from src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
rename to src/MsgPack.Abstraction/Internal/FormatEncoder.Primitives.tt
index 84556bc5c..939f76871 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder`1.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoder.Primitives.tt
@@ -14,7 +14,7 @@ using System.Runtime.CompilerServices;
 
 namespace MsgPack.Internal
 {
-	partial class Encoder<TExtensionType>
+	partial class FormatEncoder
 	{
 <#
 foreach (var inputType in new [] {
diff --git a/src/MsgPack.Abstraction/Internal/Encoder`1.cs b/src/MsgPack.Abstraction/Internal/FormatEncoder.cs
similarity index 90%
rename from src/MsgPack.Abstraction/Internal/Encoder`1.cs
rename to src/MsgPack.Abstraction/Internal/FormatEncoder.cs
index 709e4f1f9..6e85ef2a1 100644
--- a/src/MsgPack.Abstraction/Internal/Encoder`1.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoder.cs
@@ -11,17 +11,16 @@
 namespace MsgPack.Internal
 {
 	/// <summary>
-	///		Defines an interface and basic functionarity of stateless <see cref="Encoder"/>.
+	///		Defines an interface and basic functionarity of stateless <see cref="FormatEncoder"/>.
 	/// </summary>
-	/// <typeparam name="TExtensionType">A type of extension type.</typeparam>
 	/// <remarks>
-	///		The <see cref="Encoder"/> is stateless, so caller (serializer, reader, etc.) can cache the instance for performance.
+	///		The <see cref="FormatEncoder"/> is stateless, so caller (serializer, reader, etc.) can cache the instance for performance.
 	/// </remarks>
-	public abstract partial class Encoder<TExtensionType>
+	public abstract partial class FormatEncoder
 	{
-		public EncoderOptions Options { get; }
+		public FormatEncoderOptions Options { get; }
 
-		protected Encoder(EncoderOptions options)
+		protected FormatEncoder(FormatEncoderOptions options)
 		{
 			this.Options = Ensure.NotNull(options);
 		}
@@ -84,10 +83,10 @@ public void EncodeString(string? value, IBufferWriter<byte> buffer, Encoding? en
 
 		public abstract void EncodeMapValueEnd(int index, IBufferWriter<byte> buffer, in CollectionContext collectionContext);
 
-		public virtual void EncodeExtension(TExtensionType typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
+		public virtual void EncodeExtension(ExtensionType typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
 			=> Throw.ExtensionsIsNotSupported();
 
-		public virtual void EncodeExtension(TExtensionType typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
+		public virtual void EncodeExtension(ExtensionType typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
 			=> Throw.ExtensionsIsNotSupported();
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
diff --git a/src/MsgPack.Abstraction/Internal/EncoderOptions.cs b/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
similarity index 88%
rename from src/MsgPack.Abstraction/Internal/EncoderOptions.cs
rename to src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
index 8ec9bcd3b..45a60a7d1 100644
--- a/src/MsgPack.Abstraction/Internal/EncoderOptions.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
@@ -6,7 +6,7 @@
 
 namespace MsgPack.Internal
 {
-	public abstract class EncoderOptions
+	public abstract class FormatEncoderOptions
 	{
 		public int CancellationSupportThreshold { get; }
 
@@ -20,7 +20,7 @@ public abstract class EncoderOptions
 
 		public bool ClearsBuffer { get; }
 
-		protected EncoderOptions(EncoderOptionsBuilder builder)
+		protected FormatEncoderOptions(FormatEncoderOptionsBuilder builder)
 		{
 			builder = Ensure.NotNull(builder);
 
diff --git a/src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs
similarity index 90%
rename from src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs
rename to src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs
index 7fa2d2ef6..569966abc 100644
--- a/src/MsgPack.Abstraction/Internal/EncoderOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs
@@ -6,7 +6,7 @@
 
 namespace MsgPack.Internal
 {
-	public abstract class EncoderOptionsBuilder
+	public abstract class FormatEncoderOptionsBuilder
 	{
 		private int _cancellationSupportThreshold = OptionsDefaults.CancellationSupportThreshold;
 
@@ -50,9 +50,9 @@ public ArrayPool<char> CharBufferPool
 
 		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
 
-		protected EncoderOptionsBuilder() { }
+		protected FormatEncoderOptionsBuilder() { }
 
-		public EncoderOptionsBuilder WithoutBufferClear()
+		public FormatEncoderOptionsBuilder WithoutBufferClear()
 		{
 			this.ClearsBuffer = false;
 			return this;
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
index 57a1c8645..4b490fa21 100644
--- a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
@@ -18,14 +18,14 @@ public sealed class FormatFeatures
 		/// <remarks>
 		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
 		///		<list type="bullet">
-		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64)"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64, out System.Int32)"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, System.Threading.CancellationToken)"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, out System.Int32, System.Threading.CancellationToken)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, System.Threading.CancellationToken)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, out System.Int32, System.Threading.CancellationToken)"/></item>
 		///		</list>
 		/// </remarks>
 		public bool CanCountCollectionItems { get; }
@@ -50,9 +50,9 @@ public sealed class FormatFeatures
 		/// <remarks>
 		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
 		///		<list type="bullet">
-		///			<item><see cref="Encoder{TExtensionType}.EncodeExtension(TExtensionType, System.ReadOnlySpan{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
-		///			<item><see cref="Encoder{TExtensionType}.EncodeExtension(TExtensionType, System.Buffers.ReadOnlySequence{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
-		///			<item><see cref="Decoder{TExtensionType}.DecodeExtension(in System.Buffers.SequenceReader{System.Byte}, out TExtensionType, out System.Buffers.ReadOnlySequence{System.Byte}, out System.Int32, System.Threading.CancellationToken)(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.ReadOnlySpan{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.Buffers.ReadOnlySequence{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeExtension(in System.Buffers.SequenceReader{System.Byte}, out TExtensionType, out System.Buffers.ReadOnlySequence{System.Byte}, out System.Int32, System.Threading.CancellationToken)(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
 		///		</list>
 		///		In additon, <c>TExtentionType</c> type parameter should be <see cref="NullExtensionType"/>.
 		/// </remarks>
diff --git a/src/MsgPack.Abstraction/Internal/NullExtensionType.cs b/src/MsgPack.Abstraction/Internal/NullExtensionType.cs
deleted file mode 100644
index 0de495693..000000000
--- a/src/MsgPack.Abstraction/Internal/NullExtensionType.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-namespace MsgPack.Internal
-{
-	/// <summary>
-	///		Represents <c>null</c> extension type for underlying formats which do not support extension type.
-	/// </summary>
-	public struct NullExtensionType { }
-}
diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
index 08f97e67a..965c43fb5 100644
--- a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -7,38 +7,36 @@
   <ItemGroup>
     <Compile Include="../MsgPack/MessageNotSupportedException.cs" Link="MessageNotSupportedException.cs" />
     <Compile Include="../MsgPack/MessageTypeException.cs" Link="MessageTypeException.cs" />
-    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.cs" Link="Serialization\PolymorphismSchema.cs" />
-    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.Internals.cs" Link="Serialization\PolymorphismSchema.Internals.cs" />
     <Compile Include="..\MsgPack\Serialization\SerializerCapabilities.cs" Link="Serialization\SerializerCapabilities.cs" />
   </ItemGroup>
 
   <ItemGroup>
-    <None Update="Internal\Decoder`1.Strings.tt">
+    <None Update="Internal\FormatDecoder.Strings.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Decoder`1.Strings.cs</LastGenOutput>
+      <LastGenOutput>FormatDecoder.Strings.cs</LastGenOutput>
     </None>
-    <None Update="Internal\Encoder`1.Primitives.tt">
-      <LastGenOutput>Encoder`1.Primitives.cs</LastGenOutput>
+    <None Update="Internal\FormatEncoder.Primitives.tt">
+      <LastGenOutput>FormatEncoder.Primitives.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Internal\Decoder`1.Primitives.tt">
+    <None Update="Internal\FormatDecoder.Primitives.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Decoder`1.Primitives.cs</LastGenOutput>
+      <LastGenOutput>FormatDecoder.Primitives.cs</LastGenOutput>
     </None>
-    <None Update="Serialization\AsyncSerializationOperationContext`1.tt">
-      <LastGenOutput>AsyncSerializationOperationContext`1.cs</LastGenOutput>
+    <None Update="Serialization\AsyncSerializationOperationContext.tt">
+      <LastGenOutput>AsyncSerializationOperationContext.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Serialization\AsyncDeserializationOperationContext`1.tt">
-      <LastGenOutput>AsyncDeserializationOperationContext`1.cs</LastGenOutput>
+    <None Update="Serialization\AsyncDeserializationOperationContext.tt">
+      <LastGenOutput>AsyncDeserializationOperationContext.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Serialization\DeserializationOperationContext`1.tt">
-      <LastGenOutput>DeserializationOperationContext`1.cs</LastGenOutput>
+    <None Update="Serialization\DeserializationOperationContext.tt">
+      <LastGenOutput>DeserializationOperationContext.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Serialization\SerializationOperationContext`1.tt">
-      <LastGenOutput>SerializationOperationContext`1.cs</LastGenOutput>
+    <None Update="Serialization\SerializationOperationContext.tt">
+      <LastGenOutput>SerializationOperationContext.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
   </ItemGroup>
@@ -48,40 +46,40 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Update="Internal\Decoder`1.Primitives.cs">
+    <Compile Update="Internal\FormatDecoder.Primitives.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Decoder`1.Primitives.tt</DependentUpon>
+      <DependentUpon>FormatDecoder.Primitives.tt</DependentUpon>
     </Compile>
-    <Compile Update="Internal\Decoder`1.Strings.cs">
+    <Compile Update="Internal\FormatDecoder.Strings.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Decoder`1.Strings.tt</DependentUpon>
+      <DependentUpon>FormatDecoder.Strings.tt</DependentUpon>
     </Compile>
-    <Compile Update="Internal\Encoder`1.Primitives.cs">
+    <Compile Update="Internal\FormatEncoder.Primitives.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>Encoder`1.Primitives.tt</DependentUpon>
+      <DependentUpon>FormatEncoder.Primitives.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\AsyncDeserializationOperationContext`1.cs">
+    <Compile Update="Serialization\AsyncDeserializationOperationContext.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>AsyncDeserializationOperationContext`1.tt</DependentUpon>
+      <DependentUpon>AsyncDeserializationOperationContext.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\AsyncSerializationOperationContext`1.cs">
+    <Compile Update="Serialization\AsyncSerializationOperationContext.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>AsyncSerializationOperationContext`1.tt</DependentUpon>
+      <DependentUpon>AsyncSerializationOperationContext.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\DeserializationOperationContext`1.cs">
+    <Compile Update="Serialization\DeserializationOperationContext.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>DeserializationOperationContext`1.tt</DependentUpon>
+      <DependentUpon>DeserializationOperationContext.tt</DependentUpon>
     </Compile>
-    <Compile Update="Serialization\SerializationOperationContext`1.cs">
+    <Compile Update="Serialization\SerializationOperationContext.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>SerializationOperationContext`1.tt</DependentUpon>
+      <DependentUpon>SerializationOperationContext.tt</DependentUpon>
     </Compile>
   </ItemGroup>
   
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
similarity index 77%
rename from src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
index 53025b8c9..70a1d3911 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
@@ -16,16 +16,16 @@
 
 namespace MsgPack.Serialization
 {
-	public sealed class AsyncDeserializationOperationContext<TExtensionType>
+	public sealed class AsyncDeserializationOperationContext
 	{
-		public Decoder<TExtensionType> Decoder { get; }
+		public FormatDecoder Decoder { get; }
 		public DeserializationOptions Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
 		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
-		public AsyncDeserializationOperationContext(Decoder<TExtensionType> decoder, DeserializationOptions? options, CancellationToken cancellationToken)
+		public AsyncDeserializationOperationContext(FormatDecoder decoder, DeserializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Decoder = Ensure.NotNull(decoder);
 			this.Options = options ?? DeserializationOptions.Default;
@@ -33,8 +33,8 @@ public AsyncDeserializationOperationContext(Decoder<TExtensionType> decoder, Des
 			this.CancellationToken = cancellationToken;
 		}
 
-		public DeserializationOperationContext<TExtensionType> AsDeserializationOperationContext()
-			=> new DeserializationOperationContext<TExtensionType>(this.Decoder, this.Options, this.CancellationToken);
+		public DeserializationOperationContext AsDeserializationOperationContext()
+			=> new DeserializationOperationContext(this.Decoder, this.Options, this.CancellationToken);
 
 		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
 
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.tt
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
similarity index 73%
rename from src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
index 6fb561b90..0bd040e1f 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
@@ -15,15 +15,15 @@
 
 namespace MsgPack.Serialization
 {
-	public sealed class AsyncSerializationOperationContext<TExtensionType>
+	public sealed class AsyncSerializationOperationContext
 	{
-		public Encoder<TExtensionType> Encoder { get; }
+		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
-		public AsyncSerializationOperationContext(Encoder<TExtensionType> encoder, SerializationOptions? options, CancellationToken cancellationToken)
+		public AsyncSerializationOperationContext(FormatEncoder encoder, SerializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Encoder = Ensure.NotNull(encoder);
 			this.Options = options ?? SerializationOptions.Default;
@@ -31,8 +31,8 @@ public AsyncSerializationOperationContext(Encoder<TExtensionType> encoder, Seria
 			this.CancellationToken = cancellationToken;
 		}
 
-		public SerializationOperationContext<TExtensionType> AsSerializationOperationContext()
-			=> new SerializationOperationContext<TExtensionType>(this.Encoder, this.Options, this.CancellationToken);
+		public SerializationOperationContext AsSerializationOperationContext()
+			=> new SerializationOperationContext(this.Encoder, this.Options, this.CancellationToken);
 
 		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
 
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.tt
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.cs
similarity index 86%
rename from src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.cs
index b0b762a74..6e95b0627 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.cs
@@ -16,16 +16,16 @@
 
 namespace MsgPack.Serialization
 {
-	public struct DeserializationOperationContext<TExtensionType>
+	public struct DeserializationOperationContext
 	{
-		public Decoder<TExtensionType> Decoder { get; }
+		public FormatDecoder Decoder { get; }
 		public DeserializationOptions Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
 		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
-		public DeserializationOperationContext(Decoder<TExtensionType> decoder, DeserializationOptions? options, CancellationToken cancellationToken)
+		public DeserializationOperationContext(FormatDecoder decoder, DeserializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Decoder = Ensure.NotNull(decoder);
 			this.Options = options ?? DeserializationOptions.Default;
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/DeserializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.tt
diff --git a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs b/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
deleted file mode 100644
index 762b962da..000000000
--- a/src/MsgPack.Abstraction/Serialization/Internal/IObjectSerializer`2.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System.Buffers;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace MsgPack.Serialization.Internal
-{
-	public interface IObjectSerializer<T, TExtentionType>
-	{
-		void Serialize(ref SerializationOperationContext<TExtentionType> context, T obj, IBufferWriter<byte> sink);
-		ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtentionType> context, T obj, Stream streamSink);
-		T Deserialize(ref DeserializationOperationContext<TExtentionType> context, ref SequenceReader<byte> source);
-		ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext<TExtentionType> context, Stream streamSource);
-		bool DeserializeTo(ref DeserializationOperationContext<TExtentionType> context, ref SequenceReader<byte> source, in T obj);
-		ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtentionType> context, Stream streamSource, T obj);
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
new file mode 100644
index 000000000..d4f86ba0b
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
@@ -0,0 +1,17 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+#warning TODO: Remove UGLY TExtensionType
+	public sealed class ObjectSerializationContext
+	{
+		public ObjectSerializer<T> GetSerializer<T>(object providerParameter)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
new file mode 100644
index 000000000..2cdd62ec6
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
@@ -0,0 +1,43 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	public abstract class ObjectSerializer<T>
+	{
+		protected ObjectSerializationContext OwnerContext { get; }
+		public SerializerCapabilities Capabilities { get; }
+		public bool CanSerialize => (this.Capabilities & SerializerCapabilities.Serialize) != 0;
+		public bool CanDeserialize => (this.Capabilities & SerializerCapabilities.Deserialize) != 0;
+		public bool CanDeserializeTo => (this.Capabilities & SerializerCapabilities.DeserializeTo) != 0;
+
+		protected ObjectSerializer(ObjectSerializationContext ownerContext, SerializerCapabilities capabilities)
+		{
+			this.OwnerContext = Ensure.NotNull(ownerContext);
+			this.Capabilities = capabilities;
+		}
+
+		public abstract void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink);
+		public async ValueTask SerializeAsync(AsyncSerializationOperationContext context, [AllowNull] T obj, Stream streamSink)
+		{
+			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
+			{
+				var serializationOperationContext = context.AsSerializationOperationContext();
+				this.Serialize(ref serializationOperationContext, obj, writer);
+			}
+		}
+
+		[return: MaybeNull]
+		public abstract T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+		public abstract ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, Stream streamSource);
+		public abstract bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in T obj);
+		public abstract ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, Stream streamSource, T obj);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
index 8d886708e..9335f56b1 100644
--- a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
+++ b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
@@ -5,7 +5,8 @@ void WriteContext(bool isSerialization, bool isAsync)
 	var typePrefix = isSerialization ? "Serialization" : "Deserialization";
 	var typeName = $"{(isAsync ? "Async" : String.Empty)}{typePrefix}OperationContext";
 	var optionTypeName = $"{typePrefix}Options";
-	var primitive = isSerialization ? "Encoder" : "Decoder";
+	var primitiveType = isSerialization ? "FormatEncoder" : "FormatDecoder";
+	var primitiveName = isSerialization ? "Encoder" : "Decoder";
 #>
 // Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
@@ -32,9 +33,9 @@ using MsgPack.Internal;
 
 namespace MsgPack.Serialization
 {
-	public <#= typeClass #> <#= typeName #><TExtensionType>
+	public <#= typeClass #> <#= typeName #>
 	{
-		public <#= primitive #><TExtensionType> <#= primitive #> { get; }
+		public <#= primitiveType #> <#= primitiveName #> { get; }
 		public <#= optionTypeName #> Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
 <#+
@@ -48,9 +49,9 @@ namespace MsgPack.Serialization
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
-		public <#= typeName #>(<#= primitive #><TExtensionType> <#= primitive.ToLowerInvariant() #>, <#= optionTypeName #>? options, CancellationToken cancellationToken)
+		public <#= typeName #>(<#= primitiveType #> <#= primitiveName.ToLowerInvariant() #>, <#= optionTypeName #>? options, CancellationToken cancellationToken)
 		{
-			this.<#= primitive #> = Ensure.NotNull(<#= primitive.ToLowerInvariant() #>);
+			this.<#= primitiveName #> = Ensure.NotNull(<#= primitiveName.ToLowerInvariant() #>);
 			this.Options = options ?? <#= optionTypeName #>.Default;
 			this.CurrentDepth = 0;
 			this.CancellationToken = cancellationToken;
@@ -61,8 +62,8 @@ namespace MsgPack.Serialization
 	{
 		var syncTypeName = typeName.Substring("Async".Length);
 #>
-		public <#= syncTypeName #><TExtensionType> As<#= syncTypeName #>()
-			=> new <#= syncTypeName #><TExtensionType>(this.<#= primitive #>, this.Options, this.CancellationToken);
+		public <#= syncTypeName #> As<#= syncTypeName #>()
+			=> new <#= syncTypeName #>(this.<#= primitiveName #>, this.Options, this.CancellationToken);
 
 <#+
 	}
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.cs b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
similarity index 84%
rename from src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.cs
rename to src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
index 36f7ca1fc..75d24d1c2 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
@@ -15,15 +15,15 @@
 
 namespace MsgPack.Serialization
 {
-	public struct SerializationOperationContext<TExtensionType>
+	public struct SerializationOperationContext
 	{
-		public Encoder<TExtensionType> Encoder { get; }
+		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
-		public SerializationOperationContext(Encoder<TExtensionType> encoder, SerializationOptions? options, CancellationToken cancellationToken)
+		public SerializationOperationContext(FormatEncoder encoder, SerializationOptions? options, CancellationToken cancellationToken)
 		{
 			this.Encoder = Ensure.NotNull(encoder);
 			this.Options = options ?? SerializationOptions.Default;
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.tt b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/SerializationOperationContext`1.tt
rename to src/MsgPack.Abstraction/Serialization/SerializationOperationContext.tt
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer.cs b/src/MsgPack.Abstraction/Serialization/Serializer.cs
new file mode 100644
index 000000000..a07d09f2f
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/Serializer.cs
@@ -0,0 +1,29 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MsgPack.Serialization
+{
+	public abstract class Serializer
+	{
+		public abstract void SerializeObject(object? obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default);
+
+		public abstract ReadOnlyMemory<byte> SerializeObject(object? obj, CancellationToken cancellationToken = default);
+
+		public abstract ValueTask SerializeObjectAsync(object? obj, Stream streamSink, CancellationToken cancellationToken = default);
+
+		public abstract object? DeserializeObject(ref SequenceReader<byte> reader, CancellationToken cancellationToken = default);
+
+		public abstract object? DeserializeObject(ref ReadOnlySequence<byte> source, CancellationToken cancellationToken = default);
+
+		public abstract object? DeserializeObject(ref ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default);
+
+		public abstract ValueTask<object?> DeserializeObjectAsync(Stream streamSource, CancellationToken cancellationToken = default);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
index 07abafe57..f0b9fd72f 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
+++ b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
@@ -4,26 +4,26 @@
 
 using System;
 using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using MsgPack.Internal;
-using MsgPack.Serialization.Internal;
 
 namespace MsgPack.Serialization
 {
-	public abstract class Serializer<T, TExtentionType>
+	public abstract class Serializer<T> : Serializer
 	{
-		private readonly Func<Encoder<TExtentionType>> _encoderFactory;
-		private readonly Func<Decoder<TExtentionType>> _decoderFactory;
-		private readonly IObjectSerializer<T, TExtentionType> _underlying;
+		private readonly Func<FormatEncoder> _encoderFactory;
+		private readonly Func<FormatDecoder> _decoderFactory;
+		private readonly ObjectSerializer<T> _underlying;
 		private readonly SerializationOptions _serializationOptions;
 		private readonly DeserializationOptions _deserializationOptions;
 
 		protected Serializer(
-			Func<Encoder<TExtentionType>> encoderFactory,
-			Func<Decoder<TExtentionType>> decoderFactory,
-			IObjectSerializer<T, TExtentionType> underlying,
+			Func<FormatEncoder> encoderFactory,
+			Func<FormatDecoder> decoderFactory,
+			ObjectSerializer<T> underlying,
 			SerializationOptions serializationOptions,
 			DeserializationOptions deserializationOptions
 		)
@@ -35,17 +35,21 @@ DeserializationOptions deserializationOptions
 			this._deserializationOptions = Ensure.NotNull(deserializationOptions);
 		}
 
-		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext<TExtentionType> context)
-			=> context = new SerializationOperationContext<TExtentionType>(this._encoderFactory(), this._serializationOptions, cancellationToken);
+		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext context)
+			=> context = new SerializationOperationContext(this._encoderFactory(), this._serializationOptions, cancellationToken);
 
-		private void InitializeAsyncSerializationOperationContext(CancellationToken cancellationToken, out AsyncSerializationOperationContext<TExtentionType> context)
-			=> context = new AsyncSerializationOperationContext<TExtentionType>(this._encoderFactory(), this._serializationOptions, cancellationToken);
+		private void InitializeAsyncSerializationOperationContext(CancellationToken cancellationToken, out AsyncSerializationOperationContext context)
+			=> context = new AsyncSerializationOperationContext(this._encoderFactory(), this._serializationOptions, cancellationToken);
 
-		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext<TExtentionType> context)
-			=> context = new DeserializationOperationContext<TExtentionType>(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext context)
+			=> context = new DeserializationOperationContext(this._decoderFactory(), this._deserializationOptions, cancellationToken);
 
-		private void InitializeAsyncDeserializationOperationContext(CancellationToken cancellationToken, out AsyncDeserializationOperationContext<TExtentionType> context)
-			=> context = new AsyncDeserializationOperationContext<TExtentionType>(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+		private void InitializeAsyncDeserializationOperationContext(CancellationToken cancellationToken, out AsyncDeserializationOperationContext context)
+			=> context = new AsyncDeserializationOperationContext(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+
+		/// <inheritdoc />
+		public sealed override void SerializeObject(object? obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default)
+			=> this.Serialize((T)obj, cancellationToken);
 
 		public void Serialize(T obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default)
 		{
@@ -53,7 +57,11 @@ public void Serialize(T obj, IBufferWriter<byte> sink, CancellationToken cancell
 			this._underlying.Serialize(ref context, obj, sink);
 		}
 
-		public ReadOnlyMemory<byte> Serialize(T obj, CancellationToken cancellationToken = default)
+		/// <inheritdoc />
+		public sealed override ReadOnlyMemory<byte> SerializeObject(object? obj, CancellationToken cancellationToken = default)
+			=> this.Serialize((T)obj, cancellationToken);
+
+		public ReadOnlyMemory<byte> Serialize([AllowNull]T obj, CancellationToken cancellationToken = default)
 		{
 			this.InitializeSerializationOperationContext(cancellationToken, out var context);
 			var writer = new ArrayBufferWriter<byte>();
@@ -61,18 +69,31 @@ public ReadOnlyMemory<byte> Serialize(T obj, CancellationToken cancellationToken
 			return writer.WrittenMemory;
 		}
 
-		public ValueTask SerializeAsync(T obj, Stream streamSink, CancellationToken cancellationToken = default)
+		/// <inheritdoc />
+		public sealed override ValueTask SerializeObjectAsync(object? obj, Stream streamSink, CancellationToken cancellationToken = default)
+			=> this.SerializeAsync((T)obj, streamSink, cancellationToken);
+
+		public ValueTask SerializeAsync([AllowNull]T obj, Stream streamSink, CancellationToken cancellationToken = default)
 		{
 			this.InitializeAsyncSerializationOperationContext(cancellationToken, out var context);
 			return this._underlying.SerializeAsync(context, obj, streamSink);
 		}
 
+		/// <inheritdoc />
+		public sealed override object? DeserializeObject(ref SequenceReader<byte> reader, CancellationToken cancellationToken = default)
+			=> this.Deserialize(ref reader, cancellationToken);
+
+		[return:MaybeNull]
 		public T Deserialize(ref SequenceReader<byte> reader, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
 			return this._underlying.Deserialize(ref context, ref reader);
 		}
 
+		public sealed override object? DeserializeObject(ref ReadOnlySequence<byte> source, CancellationToken cancellationToken = default)
+			=> this.Deserialize(ref source, cancellationToken);
+
+		[return:MaybeNull]
 		public T Deserialize(ref ReadOnlySequence<byte> source, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
@@ -82,6 +103,11 @@ public T Deserialize(ref ReadOnlySequence<byte> source, CancellationToken cancel
 			return result;
 		}
 
+		/// <inheritdoc />
+		public sealed override object? DeserializeObject(ref ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default)
+			=> this.Deserialize(ref memorySource, cancellationToken);
+
+		[return:MaybeNull]
 		public T Deserialize(ref ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
@@ -91,6 +117,10 @@ public T Deserialize(ref ReadOnlyMemory<byte> memorySource, CancellationToken ca
 			return result;
 		}
 
+		/// <inheritdoc />
+		public sealed override async ValueTask<object?> DeserializeObjectAsync(Stream streamSource, CancellationToken cancellationToken = default)
+			=> await this.DeserializeAsync(streamSource, cancellationToken).ConfigureAwait(false);
+
 		public ValueTask<T> DeserializeAsync(Stream streamSource, CancellationToken cancellationToken = default)
 		{
 			this.InitializeAsyncDeserializationOperationContext(cancellationToken, out var context);
diff --git a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
index a41c8c45e..d95d12eb1 100644
--- a/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/CurrentMessagePackEncoder.cs
@@ -78,21 +78,26 @@ protected sealed override int EncodeBinaryHeader(uint length, Span<byte> buffer)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override void EncodeExtension(MessagePackExtensionType typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
+		public sealed override void EncodeExtension(ExtensionType typeCode, ReadOnlySpan<byte> serializedValue, IBufferWriter<byte> buffer)
 		{
 			EncodeExtensionHeader(typeCode, unchecked((uint)serializedValue.Length), buffer);
 			buffer.Write(serializedValue);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public sealed override void EncodeExtension(MessagePackExtensionType typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
+		public sealed override void EncodeExtension(ExtensionType typeCode, in ReadOnlySequence<byte> serializedValue, IBufferWriter<byte> buffer)
 		{
 			EncodeExtensionHeader(typeCode, unchecked((uint)serializedValue.Length), buffer);
 			this.WriteRaw(serializedValue, buffer);
 		}
 
-		private static void EncodeExtensionHeader(MessagePackExtensionType typeCode, uint serializedValueLength, IBufferWriter<byte> buffer)
+		private static void EncodeExtensionHeader(ExtensionType typeCode, uint serializedValueLength, IBufferWriter<byte> buffer)
 		{
+			if (typeCode.Tag > Byte.MaxValue)
+			{
+				MessagePackThrow.InvalidTypeCode(typeCode.Tag);
+			}
+
 			switch (serializedValueLength)
 			{
 				case 1:
@@ -163,7 +168,7 @@ private static void EncodeExtensionHeader(MessagePackExtensionType typeCode, uin
 			// type code
 			{
 				var span = buffer.GetSpan(1);
-				span[0] = unchecked(typeCode.TypeCode);
+				span[0] = unchecked((byte)typeCode.Tag);
 				buffer.Advance(1);
 			}
 		}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
index 71c6ac50d..790ba708f 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.DecodeItem.cs
@@ -12,12 +12,12 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		public sealed override bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult<MessagePackExtensionType> result, CancellationToken cancellationToken = default)
+		public sealed override bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default)
 		{
 			var elementType = this.ReadHeader(ref source, out var consumed, out var valueOrLength, out var requestHint);
 			if (requestHint != 0)
 			{
-				result = DecodeItemResult<MessagePackExtensionType>.InsufficientInput(requestHint);
+				result = DecodeItemResult.InsufficientInput(requestHint);
 				return false;
 			}
 
@@ -27,17 +27,17 @@ public sealed override bool DecodeItem(ref SequenceReader<byte> source, out Deco
 			{
 				case ElementType.True:
 				{
-					result = DecodeItemResult<MessagePackExtensionType>.True();
+					result = DecodeItemResult.True();
 					break;
 				}
 				case ElementType.False:
 				{
-					result = DecodeItemResult<MessagePackExtensionType>.False();
+					result = DecodeItemResult.False();
 					break;
 				}
 				case ElementType.Null:
 				{
-					result = DecodeItemResult<MessagePackExtensionType>.Null();
+					result = DecodeItemResult.Null();
 					break;
 				}
 				case ElementType.Int32:
@@ -46,14 +46,14 @@ public sealed override bool DecodeItem(ref SequenceReader<byte> source, out Deco
 					var buffer = new byte[sizeof(int)];
 					var span = MemoryMarshal.Cast<byte, int>(buffer);
 					span[0] = (int)valueOrLength;
-					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, buffer);
+					result = DecodeItemResult.ScalarOrSequence(elementType, buffer);
 					break;
 				}
 				case ElementType.Array:
 				case ElementType.Map:
 				{
 					this.DecodeArrayOrMap(ref source, out var iterator);
-					result = DecodeItemResult<MessagePackExtensionType>.CollectionHeader(elementType, this.CreateIterator((uint)valueOrLength), valueOrLength);
+					result = DecodeItemResult.CollectionHeader(elementType, this.CreateIterator((uint)valueOrLength), valueOrLength);
 					break;
 				}
 				case ElementType.Int64:
@@ -63,7 +63,7 @@ public sealed override bool DecodeItem(ref SequenceReader<byte> source, out Deco
 					var buffer = new byte[sizeof(long)];
 					var span = MemoryMarshal.Cast<byte, long>(buffer);
 					span[0] = valueOrLength;
-					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, buffer);
+					result = DecodeItemResult.ScalarOrSequence(elementType, buffer);
 					break;
 				}
 				case ElementType.String:
@@ -72,13 +72,13 @@ public sealed override bool DecodeItem(ref SequenceReader<byte> source, out Deco
 					if (source.Remaining < valueOrLength + consumed)
 					{
 						result =
-							DecodeItemResult < MessagePackExtensionType >.InsufficientInput(
+							DecodeItemResult.InsufficientInput(
 								(int)((valueOrLength + consumed - source.Remaining) & Int32.MaxValue)
 							);
 						return false;
 					}
 
-					result = DecodeItemResult<MessagePackExtensionType>.ScalarOrSequence(elementType, source.Sequence.Slice(source.Position).Slice(consumed, valueOrLength));
+					result = DecodeItemResult.ScalarOrSequence(elementType, source.Sequence.Slice(source.Position).Slice(consumed, valueOrLength));
 					consumed += valueOrLength;
 					break;
 				}
@@ -89,17 +89,17 @@ public sealed override bool DecodeItem(ref SequenceReader<byte> source, out Deco
 					if(source.Remaining < valueOrLength + consumed)
 					{
 						result =
-							DecodeItemResult<MessagePackExtensionType>.InsufficientInput(
+							DecodeItemResult.InsufficientInput(
 								(int)((valueOrLength + consumed - source.Remaining) & Int32.MaxValue)
 							);
 						return false;
 					}
 
 					var extensionSlice = source.Sequence.Slice(source.Position).Slice(consumed - 1);
-					var typeCode = new MessagePackExtensionType(extensionSlice.FirstSpan[0]);
+					var typeCode = extensionSlice.FirstSpan[0];
 					var body = extensionSlice.Slice(1, valueOrLength);
 
-					result = DecodeItemResult<MessagePackExtensionType>.ExtensionTypeObject(typeCode, body);
+					result = DecodeItemResult.ExtensionType(new ExtensionTypeObject(new ExtensionType(typeCode), body));
 					consumed += valueOrLength;
 					break;
 				}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
index 603775c8c..902e51454 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.Extension.cs
@@ -104,36 +104,33 @@ private uint ReadExtensionHeader(ref SequenceReader<byte> source, out int consum
 			return length;
 		}
 
-		public override void DecodeExtension(ref SequenceReader<byte> source, out MessagePackExtensionType typeCode, out ReadOnlySequence<byte> body, out int requestHint, CancellationToken cancellationToken = default)
+		public override void DecodeExtension(ref SequenceReader<byte> source, out ExtensionTypeObject result, out int requestHint, CancellationToken cancellationToken = default)
 		{
 			var bodyLength = this.ReadExtensionHeader(ref source, out var consumed, out requestHint);
 			if (requestHint != 0)
 			{
-				typeCode = default;
-				body = default;
+				result = default;
 				return;
 			}
 
-			if (!source.TryPeek(out byte typeCodeByte))
+			if (!source.TryPeek(out byte typeCode))
 			{
 				requestHint = 1;
-				typeCode = default;
-				body = default;
+				result = default;
 				return;
 			}
 
 			consumed++;
-			typeCode = new MessagePackExtensionType(typeCodeByte);
 
 			if (source.Remaining < consumed + bodyLength)
 			{
 				requestHint = (int)((consumed + bodyLength - (int)source.Remaining) & Int32.MaxValue);
-				body = default;
+				result = default;
 				return;
 			}
 
 			requestHint = 0;
-			body = source.Sequence.Slice(consumed, bodyLength);
+			result = new ExtensionTypeObject(new ExtensionType(typeCode), source.Sequence.Slice(consumed, bodyLength));
 			source.Advance(consumed + bodyLength);
 		}
 	}
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
index f08ec168e..4bd24d4ca 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
@@ -9,7 +9,7 @@
 
 namespace MsgPack.Internal
 {
-	public sealed partial class MessagePackDecoder : Decoder<MessagePackExtensionType>
+	public sealed partial class MessagePackDecoder : FormatDecoder
 	{
 		private static readonly FormatFeatures MessagePackFormatFeatures =
 			new FormatFeaturesBuilder
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs b/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
index 9472d0358..c608c8cc4 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoderOptions.cs
@@ -4,7 +4,7 @@
 
 namespace MsgPack.Internal
 {
-	public sealed class MessagePackDecoderOptions : DecoderOptions
+	public sealed class MessagePackDecoderOptions : FormatDecoderOptions
 	{
 		public static MessagePackDecoderOptions Default { get; } = new MessagePackDecoderOptionsBuilder().Build();
 
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs b/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs
index 291e429b8..aab974591 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoderOptionsBuilder.cs
@@ -4,7 +4,7 @@
 
 namespace MsgPack.Internal
 {
-	public sealed class MessagePackDecoderOptionsBuilder : DecoderOptionsBuilder
+	public sealed class MessagePackDecoderOptionsBuilder : FormatDecoderOptionsBuilder
 	{
 		public MessagePackDecoderOptionsBuilder() { }
 
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoder.cs b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
index 153da2005..b3647aac9 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoder.cs
@@ -14,9 +14,9 @@ namespace MsgPack.Internal
 	/// <summary>
 	///		Common encoder implementation between legacy and current MessagePack format enconders.
 	/// </summary>
-	public abstract partial class MessagePackEncoder : Encoder<MessagePackExtensionType>
+	public abstract partial class MessagePackEncoder : FormatEncoder
 	{
-#warning TODO: Can devirt?
+#warning TODO: Can devirt? If not, change to Create(MessagePackEncoderOptions)
 		public static MessagePackEncoder CreateLegacy(MessagePackEncoderOptions options) => new LegacyMessagePackEncoder(options);
 		public static MessagePackEncoder CreateCurrent(MessagePackEncoderOptions options) => new CurrentMessagePackEncoder(options);
 
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs b/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
index dfc160c3b..a36d7e9ed 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoderOptions.cs
@@ -4,7 +4,7 @@
 
 namespace MsgPack.Internal
 {
-	public sealed class MessagePackEncoderOptions : EncoderOptions
+	public sealed class MessagePackEncoderOptions : FormatEncoderOptions
 	{
 		public static MessagePackEncoderOptions Default { get; } = new MessagePackEncoderOptionsBuilder().Build();
 
diff --git a/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs b/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs
index 0f343c3c2..7ceeba6a1 100644
--- a/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackEncoderOptionsBuilder.cs
@@ -4,7 +4,7 @@
 
 namespace MsgPack.Internal
 {
-	public sealed class MessagePackEncoderOptionsBuilder : EncoderOptionsBuilder
+	public sealed class MessagePackEncoderOptionsBuilder : FormatEncoderOptionsBuilder
 	{
 		public MessagePackEncoderOptionsBuilder() { }
 
diff --git a/src/MsgPack.Core/Internal/MessagePackExtensionType.cs b/src/MsgPack.Core/Internal/MessagePackExtensionType.cs
deleted file mode 100644
index 0287bf17b..000000000
--- a/src/MsgPack.Core/Internal/MessagePackExtensionType.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-
-namespace MsgPack.Internal
-{
-	/// <summary>
-	///		Represents type code of extention types.
-	/// </summary>
-	public readonly struct MessagePackExtensionType : IEquatable<MessagePackExtensionType>
-	{
-		public byte TypeCode { get; }
-		public bool IsSystemType => this.TypeCode < 0;
-
-		internal MessagePackExtensionType(byte typeCode)
-		{
-			this.TypeCode = typeCode;
-		}
-
-		public static MessagePackExtensionType Define(byte typeCode)
-			=> new MessagePackExtensionType(Ensure.IsNotGreaterThan(typeCode, (byte)SByte.MaxValue));
-
-		/// <inheritdoc />
-		public bool Equals(MessagePackExtensionType other)
-			=> this.TypeCode == other.TypeCode;
-
-		/// <inheritdoc />
-		public override bool Equals(object? obj)
-			=> (obj is MessagePackExtensionType other) ? this.Equals(other) : false;
-
-		/// <inheritdoc />
-		public override int GetHashCode()
-			=> this.TypeCode.GetHashCode();
-
-		public static bool operator ==(MessagePackExtensionType left, MessagePackExtensionType right)
-			=> left.Equals(right);
-
-		public static bool operator !=(MessagePackExtensionType left, MessagePackExtensionType right)
-			=> !left.Equals(right);
-	}
-}
diff --git a/src/MsgPack.Core/Internal/MessagePackThrow.cs b/src/MsgPack.Core/Internal/MessagePackThrow.cs
index c9c18f9b4..7e1665bd5 100644
--- a/src/MsgPack.Core/Internal/MessagePackThrow.cs
+++ b/src/MsgPack.Core/Internal/MessagePackThrow.cs
@@ -41,5 +41,8 @@ public static void IsNotUtf8String(byte header, long position)
 
 		public static void IsNotExtension(byte header, long position)
 			=> throw new MessageTypeException($"The type is {MessagePackCode.ToString(header)}(0x{header:X2}) but it is not extension at {position:#,0}.");
+
+		public static void InvalidTypeCode(ulong typeCode)
+			=> throw new ArgumentOutOfRangeException("typeCode", $"Extension type code for MessagePack must be 1 byte, but 0x{typeCode:X} is specified.");
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs b/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
index 9fe873247..a72edb68d 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.DecodeItem.cs
@@ -9,8 +9,6 @@
 using System.Threading;
 using MsgPack.Internal;
 
-using DecodeItemResult = MsgPack.Internal.DecodeItemResult<MsgPack.Internal.NullExtensionType>;
-
 namespace MsgPack.Json
 {
 	public partial class JsonDecoder
diff --git a/src/MsgPack.Json/Json/JsonDecoder.cs b/src/MsgPack.Json/Json/JsonDecoder.cs
index aa17d1b2d..537d503fe 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.cs
@@ -12,7 +12,7 @@ namespace MsgPack.Json
 	/// <summary>
 	///		A decoder for JSON format.
 	/// </summary>
-	public abstract partial class JsonDecoder : Decoder<NullExtensionType>
+	public abstract partial class JsonDecoder : FormatDecoder
 	{
 		private static readonly FormatFeatures JsonFormatFeatures =
 			new FormatFeaturesBuilder
diff --git a/src/MsgPack.Json/Json/JsonDecoderOptions.cs b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
index 6ff0dc68e..43f77b5e7 100644
--- a/src/MsgPack.Json/Json/JsonDecoderOptions.cs
+++ b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
@@ -9,7 +9,7 @@ namespace MsgPack.Json
 	/// <summary>
 	///		Defines decoder options for <see cref="JsonDecoder"/>.
 	/// </summary>
-	public class JsonDecoderOptions : DecoderOptions
+	public class JsonDecoderOptions : FormatDecoderOptions
 	{
 		public static JsonDecoderOptions Default { get; } = new JsonDecoderOptionsBuilder().Build();
 
diff --git a/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs b/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs
index 2ac9b8d4a..7bb7bffcb 100644
--- a/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs
+++ b/src/MsgPack.Json/Json/JsonDecoderOptionsBuilder.cs
@@ -9,7 +9,7 @@ namespace MsgPack.Json
 	/// <summary>
 	///		A builder object for immutable <see cref="JsonDecoderOptions"/>.
 	/// </summary>
-	public class JsonDecoderOptionsBuilder : DecoderOptionsBuilder
+	public class JsonDecoderOptionsBuilder : FormatDecoderOptionsBuilder
 	{
 		public JsonParseOptions ParseOptions { get; set; }
 
diff --git a/src/MsgPack.Json/Json/JsonEncoder.cs b/src/MsgPack.Json/Json/JsonEncoder.cs
index d70a1bfa3..b4109419d 100644
--- a/src/MsgPack.Json/Json/JsonEncoder.cs
+++ b/src/MsgPack.Json/Json/JsonEncoder.cs
@@ -17,7 +17,7 @@ namespace MsgPack.Json
 	/// <summary>
 	///		An encoder for JSON format.
 	/// </summary>
-	public sealed class JsonEncoder : Encoder<NullExtensionType>
+	public sealed class JsonEncoder : FormatEncoder
 	{
 		private readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> _singleInfinityFormatter;
 		private readonly Action<float, IBufferWriter<byte>, JsonEncoderOptions> _singleNanFormatter;
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptions.cs b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
index 0fa00f966..cc12fa8f3 100644
--- a/src/MsgPack.Json/Json/JsonEncoderOptions.cs
+++ b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
@@ -13,7 +13,7 @@ namespace MsgPack.Json
 	/// <summary>
 	///		Defines encoder options for <see cref="JsonEncoder"/>.
 	/// </summary>
-	public sealed class JsonEncoderOptions : EncoderOptions
+	public sealed class JsonEncoderOptions : FormatEncoderOptions
 	{
 		public static JsonEncoderOptions Default { get; } = new JsonEncoderOptionsBuilder().Build();
 
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs b/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
index 812dc7680..04634193c 100644
--- a/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
+++ b/src/MsgPack.Json/Json/JsonEncoderOptionsBuilder.cs
@@ -10,9 +10,9 @@
 namespace MsgPack.Json
 {
 	/// <summary>
-	///		A builder object to construct immutable <see cref="EncoderOptions"/> object.
+	///		A builder object to construct immutable <see cref="FormatEncoderOptions"/> object.
 	/// </summary>
-	public class JsonEncoderOptionsBuilder : EncoderOptionsBuilder
+	public class JsonEncoderOptionsBuilder : FormatEncoderOptionsBuilder
 	{
 		private static readonly ReadOnlyMemory<byte> DefaultIndentChars =
 			new byte[] { (byte)' ', (byte)' ' };
diff --git a/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj b/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj
new file mode 100644
index 000000000..a20cb1dcc
--- /dev/null
+++ b/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.ConstructorDelegate.cs" Link="Serialization\ReflectionExtensions.ConstructorDelegate.cs" />
+    <Compile Include="..\MsgPack\Serialization\Reflection\TracingILGenerator.conveniences.cs" Link="Serialization\Reflection\TracingILGenerator.conveniences.cs" />
+    <Compile Include="..\MsgPack\Serialization\Reflection\TracingILGenerator.cs" Link="Serialization\Reflection\TracingILGenerator.cs" />
+    <Compile Include="..\MsgPack\Serialization\Reflection\TracingILGenerator.emits.cs" Link="Serialization\Reflection\TracingILGenerator.emits.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Serialization\Reflection\" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj b/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
index cb6319069..1f7897a73 100644
--- a/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
+++ b/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
@@ -4,4 +4,9 @@
     <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\MsgPack.Abstraction\MsgPack.Abstraction.csproj" />
+    <ProjectReference Include="..\MsgPack.Serialization\MsgPack.Serialization.csproj" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs
new file mode 100644
index 000000000..aded3dd65
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+using MsgPack.Serialization;
+using MsgPack.Serialization.Internal;
+
+namespace Msgpack.Serialization.ReflectionSerializers
+{
+	internal abstract class SerializerBuilder
+	{
+		public abstract IObjectSerializer<T, TExtensionType> Build<T, TExtensionType>(SerializationTarget target);
+	}
+
+	internal sealed class ReflectionSerializerBuilder : SerializerBuilder
+	{
+		public sealed override IObjectSerializer<T, TExtensionType> Build<T, TExtensionType>(SerializationTarget target, SerializerGenerationOptions options)
+			=> new ReflectionSerializer<T, TExtensionType>(target, options);
+	}
+
+	/// <summary>
+	///		 Implements non optimized, reflection based serializer.
+	/// </summary>
+	/// <typeparam name="T">Type of serialization target.</typeparam>
+	/// <typeparam name="TExtensionType">Type of extention type specific to codec.</typeparam>
+	internal sealed class ReflectionSerializer<T, TExtensionType> : IObjectSerializer<T, TExtensionType>
+	{
+		private readonly SerializerGenerationOptions _options;
+#warning TODO: Use _options
+		private bool UsesArray => true;
+		// T is PrimitiveEncoder | Stringncoder | BinaryEncoder | ExtensionEncoder | ArrayEncoderToken | DictionaryEncoderToken
+		private readonly IReadOnlyList<object> _memberValueEncoders;
+		private readonly IReadOnlyList<byte[]> _memberUtf8Names;
+		private readonly IReadOnlyList<object> _memberValueDecoders;
+
+		private delegate void PrimitiveEncoder(Encoder<TExtensionType> encoder, object value, IBufferWriter<byte> writer);
+		private delegate void Stringncoder(Encoder<TExtensionType> encoder, object value, IBufferWriter<byte> writer, Encoding? encoding, CancellationToken cancellationToken);
+		private delegate void BinaryEncoder(Encoder<TExtensionType> encoder, object ovaluebj, IBufferWriter<byte> writer, CancellationToken cancellationToken);
+		private delegate void ExtensionEncoder(Encoder<TExtensionType> encoder, TExtensionType extensionType, in ReadOnlySequence<byte> body, IBufferWriter<byte> writer, CancellationToken cancellationToken);
+
+		public void Serialize(ref SerializationOperationContext<TExtensionType> context, [AllowNull] T obj, IBufferWriter<byte> sink)
+		{
+			var encoder = context.Encoder;
+			if (obj is null)
+			{
+				encoder.EncodeNull(sink);
+				return;
+			}
+
+			if (this.UsesArray)
+			{
+				encoder.EncodeArrayStart(this._memberValueEncoders.Count, sink, context.CollectionContext);
+
+				for(var i = 0; i < this._memberValueEncoders.Count;i++)
+				{
+					encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+					if (this._memberValueEncoders[i] is Action<object, IBufferWriter<byte>> primitiveEncoder)
+					{
+						encoder.EncodeBinary()
+					}
+					else if (this._memberValueEncoders[i] is Action<object, IBufferWriter<byte>, Encoding?, CancellationToken> stringEncoder)
+					{
+
+					}
+					else if (this._memberValueEncoders[i] is Action<object, IBufferWriter<byte>, CancellationToken> binaryEncoder)
+					{
+
+					}
+					else if (this._memberValueEncoders[i] is Action<object, ReadOnlySequence<byte>, IBufferWriter<byte>> extensionEncoder)
+					{
+						encoder.EncodeExtension()
+					}
+					else
+					{
+						Debug.Fail();
+					}
+					encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+				}
+
+				encoder.EncodeArrayEnd(this._memberValueEncoders.Count, sink, context.CollectionContext);
+
+			}
+			
+
+
+			throw new NotImplementedException();
+		}
+
+		public async ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, [AllowNull] T obj, Stream streamSink)
+		{
+			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
+			{
+				var serializationOperationContext = context.AsSerializationOperationContext();
+				this.Serialize(ref serializationOperationContext, obj, writer);
+			}
+		}
+
+		[return: MaybeNull]
+		public T Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source, in T obj)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, T obj)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/MsgPack.Serialization.csproj b/src/MsgPack.Serialization/MsgPack.Serialization.csproj
index d7a9b6293..870dcf339 100644
--- a/src/MsgPack.Serialization/MsgPack.Serialization.csproj
+++ b/src/MsgPack.Serialization/MsgPack.Serialization.csproj
@@ -4,6 +4,49 @@
     <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\MsgPack.Abstraction\Ensure.cs" Link="Ensure.cs" />
+    <Compile Include="..\MsgPack.Abstraction\Internal\MethodImplOptionsShim.cs" Link="Internal\MethodImplOptionsShim.cs" />
+    <Compile Include="..\MsgPack\ReflectionAbstractions.cs" Link="ReflectionAbstractions.cs" />
+    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs" Link="Serialization\BindingOptions.cs" />
+    <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs" Link="Serialization\CollectionDetailedKind.cs" />
+    <Compile Include="..\MsgPack\Serialization\CollectionKind.cs" Link="Serialization\CollectionKind.cs" />
+    <Compile Include="..\MsgPack\Serialization\CollectionTraitOptions.cs" Link="Serialization\CollectionTraitOptions.cs" />
+    <Compile Include="..\MsgPack\Serialization\CollectionTraits.cs" Link="Serialization\CollectionTraits.cs" />
+    <Compile Include="..\MsgPack\Serialization\DataMemberContract.cs" Link="Serialization\DataMemberContract.cs" />
+    <Compile Include="..\MsgPack\Serialization\DateTimeConversionMethod.cs" Link="Serialization\DateTimeConversionMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\DateTimeMemberConversionMethod.cs" Link="Serialization\DateTimeMemberConversionMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\EnumMemberSerializationMethod.cs" Link="Serialization\EnumMemberSerializationMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\EnumSerializationMethod.cs" Link="Serialization\EnumSerializationMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackDateTimeMemberAttribute.cs" Link="Serialization\MessagePackDateTimeMemberAttribute.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackDeserializationConstructorAttribute.cs" Link="Serialization\MessagePackDeserializationConstructorAttribute.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackEnumAttribute.cs" Link="Serialization\MessagePackEnumAttribute.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackEnumMemberAttribute.cs" Link="Serialization\MessagePackEnumMemberAttribute.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackIgnoreAttribute.cs" Link="Serialization\MessagePackIgnoreAttribute.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackKnownTypeAttributes.cs" Link="Serialization\MessagePackKnownTypeAttributes.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackMemberAttribute.cs" Link="Serialization\MessagePackMemberAttribute.cs" />
+    <Compile Include="..\MsgPack\Serialization\MessagePackRuntimeTypeAttributes.cs" Link="Serialization\MessagePackRuntimeTypeAttributes.cs" />
+    <Compile Include="..\MsgPack\Serialization\NilImplication.cs" Link="Serialization\NilImplication.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphicTypeVerificationContext.cs" Link="Serialization\PolymorphicTypeVerificationContext.cs" />
+    <Compile Include="..\MsgPack\Serialization\Polymorphic\IPolymorphicHelperAttributes.cs" Link="Serialization\Polymorphic\IPolymorphicHelperAttributes.cs" />
+    <Compile Include="..\MsgPack\Serialization\Polymorphic\RuntimeTypeVerifier.cs" Link="Serialization\Polymorphic\RuntimeTypeVerifier.cs" />
+    <Compile Include="..\MsgPack\Serialization\Polymorphic\TypeInfoEncoding.cs" Link="Serialization\Polymorphic\TypeInfoEncoding.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.Constructors.cs" Link="Serialization\PolymorphismSchema.Constructors.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.cs" Link="Serialization\PolymorphismSchema.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.Internals.cs" Link="Serialization\PolymorphismSchema.Internals.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismSchemaChildrenType.cs" Link="Serialization\PolymorphismSchemaChildrenType.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismTarget.cs" Link="Serialization\PolymorphismTarget.cs" />
+    <Compile Include="..\MsgPack\Serialization\PolymorphismType.cs" Link="Serialization\PolymorphismType.cs" />
+    <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.CollectionTraits.cs" Link="Serialization\ReflectionExtensions.CollectionTraits.cs" />
+    <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.cs" Link="Serialization\ReflectionExtensions.cs" />
+    <Compile Include="..\MsgPack\Serialization\Reflection\GenericTypeExtensions.cs" Link="Serialization\Reflection\GenericTypeExtensions.cs" />
+    <Compile Include="..\MsgPack\Serialization\Reflection\ReflectionExtensions.cs" Link="Serialization\Reflection\ReflectionExtensions.cs" />
+    <Compile Include="..\MsgPack\Serialization\SerializationTarget.cs" Link="Serialization\SerializationTarget.cs" />
+    <Compile Include="..\MsgPack\Serialization\SerializingMember.cs" Link="Serialization\SerializingMember.cs" />
+    <Compile Include="..\MsgPack\StringEscape.cs" Link="StringEscape.cs" />
+    <Compile Include="..\MsgPack\TupleItems.cs" Link="TupleItems.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\MsgPack.Abstraction\MsgPack.Abstraction.csproj" />
   </ItemGroup>
@@ -12,4 +55,24 @@
     <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Internal\" />
+    <Folder Include="Serialization\Polymorphic\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Serialization\Throw.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Throw.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Serialization\Throw.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Throw.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
 </Project>
diff --git a/src/MsgPack.Serialization/Properties/AssemblyInfo.cs b/src/MsgPack.Serialization/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..ddec96c21
--- /dev/null
+++ b/src/MsgPack.Serialization/Properties/AssemblyInfo.cs
@@ -0,0 +1,13 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+#if DEBUG
+[assembly: InternalsVisibleTo("MsgPack.Serialization.UnitTest")]
+[assembly: InternalsVisibleTo("MsgPack.Serialization.ILGeneration.UnitTest")]
+[assembly: InternalsVisibleTo("MsgPack.Serialization.Reflection.UnitTest")]
+#endif // DEBUG
+[assembly: InternalsVisibleTo("MsgPack.Serialization.ILGeneration")]
+[assembly: InternalsVisibleTo("MsgPack.Serialization.Reflection")]
diff --git a/src/MsgPack.Serialization/Serialization/MessagePackNullableAttribute.cs b/src/MsgPack.Serialization/Serialization/MessagePackNullableAttribute.cs
new file mode 100644
index 000000000..246c1f0dd
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/MessagePackNullableAttribute.cs
@@ -0,0 +1,19 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+#if FEATURE_MPCONTRACT
+using Contract = MsgPack.MPContract;
+#else
+#endif // FEATURE_MPCONTRACT
+
+namespace MsgPack.Serialization
+{
+#warning TODO: Qualify MessagsePackObject with this attribute.
+	/// <summary>
+	///		Indicates that the default value of this value type means <c>null</c> even if the declared member type is not <see cref="Nullable{T}"/>.
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Enum | AttributeTargets.Struct)]
+	public sealed class MessagePackNullableAttribute : Attribute { }
+}
diff --git a/src/MsgPack.Serialization/Serialization/Reflection/EncoderMethods.cs b/src/MsgPack.Serialization/Serialization/Reflection/EncoderMethods.cs
new file mode 100644
index 000000000..a6c01206a
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Reflection/EncoderMethods.cs
@@ -0,0 +1,76 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Reflection
+{
+	internal static class EncoderMethods
+	{
+		public static readonly MethodInfo EncodeInt32NonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeInt32), new[] { typeof(int), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeInt32Nullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeInt32), new[] { typeof(int?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeInt64NonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeInt64), new[] { typeof(long), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeInt64Nullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeInt64), new[] { typeof(long?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeUInt32NonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeUInt32), new[] { typeof(uint), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeUInt32Nullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeUInt32), new[] { typeof(uint?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeUInt64NonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeUInt64), new[] { typeof(ulong), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeUInt64Nullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeUInt64), new[] { typeof(ulong?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeBooleanNonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeBoolean), new[] { typeof(bool), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeBooleanNullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeBoolean), new[] { typeof(bool?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeSingleNonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeSingle), new[] { typeof(float), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeSingleNullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeSingle), new[] { typeof(float?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeDoubleNonNull =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeDouble), new[] { typeof(double), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeDoubleNullable =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeDouble), new[] { typeof(double?), typeof(IBufferWriter<byte>) })!;
+
+		public static readonly MethodInfo EncodeStringString =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeString), new[] { typeof(string), typeof(IBufferWriter<byte>), typeof(Encoding), typeof(CancellationToken) })!;
+
+		public static readonly MethodInfo EncodeStringStringBuilder =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeString), new[] { typeof(StringBuilder), typeof(IBufferWriter<byte>), typeof(Encoding), typeof(CancellationToken) })!;
+
+		public static readonly MethodInfo EncodeStringSpan =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeString), new[] { typeof(ReadOnlySpan<char>), typeof(IBufferWriter<byte>), typeof(Encoding), typeof(CancellationToken) })!;
+
+		public static readonly MethodInfo EncodeStringSequence =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeString), new[] { typeof(ReadOnlySequence<char>), typeof(IBufferWriter<byte>), typeof(Encoding), typeof(CancellationToken) })!;
+
+		public static readonly MethodInfo EncodeBinarySpan =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeBinary), new[] { typeof(ReadOnlySpan<byte>), typeof(IBufferWriter<byte>), typeof(CancellationToken) })!;
+
+		public static readonly MethodInfo EncodeBinarySequence =
+			typeof(FormatEncoder).GetMethod(nameof(FormatEncoder.EncodeBinary), new[] { typeof(ReadOnlySequence<byte>), typeof(IBufferWriter<byte>), typeof(CancellationToken) })!;
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Reflection/SpanMethods.cs b/src/MsgPack.Serialization/Serialization/Reflection/SpanMethods.cs
new file mode 100644
index 000000000..e52f683cf
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Reflection/SpanMethods.cs
@@ -0,0 +1,37 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Linq;
+using System.Reflection;
+
+namespace MsgPack.Serialization.Reflection
+{
+	internal static class SpanMethods
+	{
+		private static MethodInfo GetAsReadOnlySpan<T>()
+		{
+			var parameterTypes = ArrayPool<Type>.Shared.Rent(1);
+			try
+			{
+				return
+					typeof(Span<>).MakeGenericType(typeof(T)).GetMethods(BindingFlags.Static | BindingFlags.Public)
+					.Single(m =>
+						m.ReturnType == typeof(ReadOnlySpan<T>)
+						&& m.Name == "op_Implicit"
+						&& m.GetParameterTypes().SequenceEqual(parameterTypes)
+					);
+			}
+			finally
+			{
+				ArrayPool<Type>.Shared.Return(parameterTypes);
+			}
+		}
+
+		public static readonly MethodInfo AsReadOnlySpanByte = GetAsReadOnlySpan<byte>();
+
+		public static readonly MethodInfo AsReadOnlySpanChar = GetAsReadOnlySpan<char>();
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs b/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs
new file mode 100644
index 000000000..03092fc25
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs
@@ -0,0 +1,11 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal abstract class SerializerBuilder
+	{
+		public abstract ObjectSerializer<T> Build<T>(ObjectSerializationContext context, SerializationTarget target);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs b/src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs
new file mode 100644
index 000000000..820c44f71
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs
@@ -0,0 +1,60 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace MsgPack.Serialization
+{
+	public readonly struct MessagePackMemberAttributeData
+	{
+		public int? Id { get; }
+		public string? Name { get; }
+
+		public MessagePackMemberAttributeData(int? id, string? name)
+		{
+			this.Id = id == null ? id : Ensure.IsNotLessThan(id.GetValueOrDefault(), 0, nameof(id));
+			this.Name = name;
+		}
+	}
+
+	internal sealed class SerializerGenerationOptions
+	{
+		public bool DisablesPrivilegedAccess { get; }
+		public bool OneBoundDataMemberOrder { get; }
+		public bool AllowsAsymmetricSerializer { get; }
+		public ISet<string> IgnoreAttributeTypeNames { get; }
+		public Func<Type, SerializerGenerationOptions, bool> SerializableAnywayInterfaceDetector { get; } 
+		public Func<Type, SerializerGenerationOptions, bool> DeserializableInterfaceDetector { get; }
+		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?>? MessagePackMemberAttributeCompatibilityProvider { get; }
+		public IReadOnlyDictionary<Type, IEnumerable<string>> IgnoringMembers { get; }
+	}
+
+	public sealed class SerializerGenerationOptionsBuilder
+	{
+		private static readonly string[] DefaultIgnoreAttributeTypeNames =
+			new[]
+			{
+				"MsgPack.Serialization.MessagePackIgnoreAttribute",
+				"System.Runtime.Serialization.IgnoreDataMemberAttribute"
+			};
+
+#warning TODO: CompatiblityPackage:	typeof(IPackable).IsAssignableFrom(t) || typeof(IUnpackable).IsAssignableFrom(t) || (!o.WithAsync || typeof(IAsyncPackable).IsAssignableFrom(t) || typeof(IAsyncUnpackable).IsAssignableFrom(t))
+		private static readonly Func<Type, SerializerGenerationOptions, bool>[] DefaultSerializableAnywayInterfaceDetectors = Array.Empty<Func<Type, SerializerGenerationOptions, bool>>();
+
+#warning TODO: CompatiblityPackage: typeof(IUnpackable).IsAssignableFrom(t) && (!o.WithAsync || typeof(IAsyncUnpackable).IsAssignable(t))
+		private static readonly Func<Type, SerializerGenerationOptions, bool>[] DefaultDeserializableInterfaceDetectors = Array.Empty<Func<Type, SerializerGenerationOptions, bool>>();
+
+		internal IList<Func<Type, SerializerGenerationOptions, bool>> SerializableAnywayInterfaceDetectors { get; } = new List<Func<Type, SerializerGenerationOptions, bool>>(DefaultSerializableAnywayInterfaceDetectors);
+		internal IList<Func<Type, SerializerGenerationOptions, bool>> DeserializableInterfaceDetectors { get; } = new List<Func<Type, SerializerGenerationOptions, bool>>(DefaultDeserializableInterfaceDetectors);
+
+		public bool DisablesPrivilegedAccess { get; set; }
+		public bool OneBoundDataMemberOrder { get; set; }
+		public bool AllowsAsymmetricSerializer { get; set; }
+		public ISet<string> IgnoreAttributeTypeNames { get; } = new HashSet<string>(DefaultIgnoreAttributeTypeNames, StringComparer.Ordinal);
+		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?>? MessagePackMemberAttributeCompatibilityProvider { get; set; }
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Throw.Internal.cs b/src/MsgPack.Serialization/Serialization/Throw.Internal.cs
new file mode 100644
index 000000000..c622df9dd
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Throw.Internal.cs
@@ -0,0 +1,125 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Serialization;
+
+namespace MsgPack.Serialization
+{
+	internal partial class Throw
+	{
+		public static void NotSupportedBecauseCannotInstanciateAbstractType(Type type)
+			=> throw new NotSupportedException($"This operation is not supported because '{type}' cannot be instanciated.");
+
+		public static void DuplicatedAttributes(Dictionary<string, List<MemberInfo>> duplicated)
+			=> throw new InvalidOperationException(
+				$"Some member keys specified with custom attributes are duplicated. " +
+				$"Details: {{{String.Join(", ", duplicated.Select(kv => $"\"{kv.Key}\":[{String.Join(", ", kv.Value.Select(m => $"{m.DeclaringType}.{m.Name}({m.MemberType})"))}]"))}}}"
+			);
+
+		public static void MemberIdIsDuplicated(int id, Type targetType)
+			=> throw new SerializationException($"The member ID '{id}' is duplicated in the '{targetType}' elementType.");
+
+		public static void DataMemberAttributeCannotBeZeroWhenOneBoundDataMemberOrderIsTrue(Type declaringType, string? memberName)
+			=> throw new NotSupportedException(
+				$"Cannot specify order value 0 on DataMemberAttribute for '{declaringType}.{memberName}' " +
+				$"when SerializationContext.CompatibilityOptions.OneBoundDataMemberOrder is set to true."
+			);
+
+		public static void TypeCannotBeSerializedBecauseNoMembersAndNoParameterizedPublicConstructors(Type targetType)
+			=> new SerializationException(
+				$"Cannot serialize type '{targetType}' because it does not have any serializable fields nor properties, " +
+				$"and it does not have any public constructors with parameters."
+			);
+
+		public static void TypeCannotBeSerializedBecauseNoMembersAndAmbigiousConstructors(Type targetType, IEnumerable<ConstructorInfo> mostRichConstructors)
+			=> throw new SerializationException(
+				$"Cannot serialize type '{targetType}' because it does not have any serializable fields nor properties, " +
+				$"and serializer generator failed to determine constructor to deserialize among declared constructors" +
+				$"({String.Join(", ", mostRichConstructors.Select(ctor => ctor.ToString()).ToArray())})."
+			);
+
+		public static void TypeCannotBeSerializedBecauseThereAreMultipleMessagePackDeserializationConstrutorAttribute(Type targetType)
+			=> throw new SerializationException(
+				$"There are multiple constructors marked with MessagePackDeserializationConstrutorAttribute in type '{targetType}'."
+			);
+
+		public static void FailedToGetProperty(string propertyName, string? assemblyQualifiedName)
+			=> throw new SerializationException($"Failed to get {propertyName} property from {assemblyQualifiedName} type.");
+
+		public static void MemberIsMarkedWithMemberAndIgnoreAttribute(Type type, string memberName)
+			=> throw new SerializationException($"A member '{memberName}' of type '{type}' is marked with both MessagePackMemberAttribute and MessagePackIgnoreAttribute.");
+
+		public static void TargetDoesNotHavePublicDefaultConstructor(Type targetType)
+			=> throw new SerializationException($"Type '{targetType}' does not have default (parameterless) public constructor.");
+
+		public static void IsNotSerializableAnyway(Type targetType)
+			=> throw new SerializationException($"Cannot serialize type '{targetType}' because it does not have any serializable fields nor properties.");
+
+		public static void UnpackToIsNotSupported(Type type, Exception inner)
+			=> throw new NotSupportedException($"This operation is not supported for '{type}' because it does not have accessible Add(T) method.", inner);
+
+		public static void UnexpectedBinaryType(object? value)
+			=> throw new NotSupportedException($"Type '{value?.GetType()}' is unexpected for binary value.");
+
+		public static void UnexpectedStringType(object? value)
+			=> throw new NotSupportedException($"Type '{value?.GetType()}' is unexpected for string value.");
+
+		public static void CannotSerializeNonPublicTypeUnlessPrivledgedAccessEnabled(Type targetType)
+			=> throw new SerializationException($"Cannot serialize type '{targetType}' because it is not public to the serializer.");
+
+		public static void NoConstructorForCollection(Type targetType)
+			=> throw new SerializationException($"Cannot deserialize collection type '{targetType}' because it does not have both of public default constructor and public consctructor with Int32 capacity parameter.");
+
+		public static object? UndeserializableCollection(Type targetType)
+			=> throw new NotSupportedException($"A generated serialzier for '{targetType}' does not supprot deserialization because the type does not expose Add method.");
+	}
+
+#warning EXTRACT
+	internal static class DiagnosticsSourceExtensions
+	{
+		private const string Prefix = "MsgPack.Serialization.";
+		private const string PolymorphicPrefix = Prefix + "Polymorphic.";
+
+		public static void DeserializationConstructorFound(this DiagnosticSource source, object value)
+			=> source.Write(Prefix + "DeserializationConstructorFound", value);
+
+		public static void DetectedAsDeserializable(this DiagnosticSource source, object value)
+			=> source.Write(Prefix + "DetectedAsDeserializable", value);
+
+		public static void DefaultPolymorphicSchemaForValueType(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "DefaultSchemaForValueType", value);
+
+		public static void PolymorphicSchemaCreatedForRootType(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "SchemaCreatedForRootType", value);
+
+		public static void DefaultPolymorphicSchemaForUnqualifiedCollectionMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedCollectionMember", value);
+
+		public static void PolymorphicSchemaCreatedForCollectionMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "SchemaCreatedForCollectionMember", value);
+
+		public static void DefaultPolymorphicSchemaForUnqualifiedDictionaryMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedDictionaryMember", value);
+
+		public static void PolymorphicSchemaCreatedForDictionaryMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "SchemaCreatedForDictionaryMember", value);
+
+		public static void DefaultPolymorphicSchemaForUnqualifiedTupleMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedTupleMember", value);
+
+		public static void PolymorphicSchemaCreatedForTupleMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "SchemaCreatedForTupleMember", value);
+
+		public static void DefaultPolymorphicSchemaForUnqualifiedObjectMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedObjectMember", value);
+
+		public static void PolymorphicSchemaCreatedForObjectMember(this DiagnosticSource source, object value)
+			=> source.Write(PolymorphicPrefix + "SchemaCreatedForObjectMember", value);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Throw.cs b/src/MsgPack.Serialization/Serialization/Throw.cs
new file mode 100644
index 000000000..2afefd965
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Throw.cs
@@ -0,0 +1,34 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Reflection;
+using System.Runtime.Serialization;
+
+namespace MsgPack.Serialization
+{
+	internal static partial class Throw
+	{
+		public static void ValueTypeCannotBeNull(string? name, Type memberType, Type declaringType)
+			=> throw new SerializationException($"Member '{name}' of type '{declaringType}' cannot be null because the member type is non-nullable value type('{memberType}').");
+
+		public static void NullIsProhibitedForReadOnlyMember(string? memberName)
+			=> throw new SerializationException($"The member '{memberName}' cannot be set null because it is read only.");
+
+		public static void UnsettableCollectionMemberMustNotBeNull(MemberInfo member)
+			=> throw new SerializationException($"Unsettable member '{member}' in '{member?.DeclaringType}' returns null collection.");
+
+		public static void UnsettableCollectionMemberTypeMustNotBeReadOnly(MemberInfo member)
+			=> throw new SerializationException($"Type of unsettable member '{member}' in '{member?.DeclaringType}' is read only collection type ('{member?.GetMemberValueType()}').");
+
+		public static void DeserializeToOnlyAvailableForMutableCollection(Type targetType)
+			=> throw new NotSupportedException($"DeserializeTo is not available because '{targetType}' is not a mutable collection.");
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Throw.tt b/src/MsgPack.Serialization/Serialization/Throw.tt
new file mode 100644
index 000000000..bdad36598
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Throw.tt
@@ -0,0 +1,10 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="./Throw.ttinclude" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ output extension=".cs" #>
+<#
+	WriteSerializationExceptions();
+#>
diff --git a/src/MsgPack.Serialization/Serialization/Throw.ttinclude b/src/MsgPack.Serialization/Serialization/Throw.ttinclude
new file mode 100644
index 000000000..42bb6b028
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Throw.ttinclude
@@ -0,0 +1,41 @@
+<#+
+void WriteSerializationExceptions()
+{
+#>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Reflection;
+using System.Runtime.Serialization;
+
+namespace MsgPack.Serialization
+{
+	internal static partial class Throw
+	{
+		public static void ValueTypeCannotBeNull(string? name, Type memberType, Type declaringType)
+			=> throw new SerializationException($"Member '{name}' of type '{declaringType}' cannot be null because the member type is non-nullable value type('{memberType}').");
+
+		public static void NullIsProhibitedForReadOnlyMember(string? memberName)
+			=> throw new SerializationException($"The member '{memberName}' cannot be set null because it is read only.");
+
+		public static void UnsettableCollectionMemberMustNotBeNull(MemberInfo member)
+			=> throw new SerializationException($"Unsettable member '{member}' in '{member?.DeclaringType}' returns null collection.");
+
+		public static void UnsettableCollectionMemberTypeMustNotBeReadOnly(MemberInfo member)
+			=> throw new SerializationException($"Type of unsettable member '{member}' in '{member?.DeclaringType}' is read only collection type ('{member?.GetMemberValueType()}').");
+
+		public static void DeserializeToOnlyAvailableForMutableCollection(Type targetType)
+			=> throw new NotSupportedException($"DeserializeTo is not available because '{targetType}' is not a mutable collection.");
+	}
+}
+<#+
+}
+#>
diff --git a/src/MsgPack.Serialization/Utf8String.cs b/src/MsgPack.Serialization/Utf8String.cs
new file mode 100644
index 000000000..79ed68136
--- /dev/null
+++ b/src/MsgPack.Serialization/Utf8String.cs
@@ -0,0 +1,40 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace MsgPack
+{
+#if !FEATURE_UTF8_STRING
+
+	internal sealed class Utf8String
+	{
+		private readonly byte[] _bytes;
+
+		public Utf8String(ReadOnlySpan<char> value)
+		{
+			var bytes = new byte[Encoding.UTF8.GetByteCount(value)];
+
+			var used = Encoding.UTF8.GetBytes(value, bytes);
+			this._bytes = bytes;
+		}
+
+		public Utf8Span AsSpan() => new Utf8Span(this._bytes);
+	}
+
+	[StructLayout(LayoutKind.Auto)]
+	internal readonly ref struct Utf8Span
+	{
+		public ReadOnlySpan<byte> Bytes { get; }
+
+		internal Utf8Span(byte[] bytes)
+		{
+			this.Bytes = bytes;
+		}
+	}
+
+#endif
+}
diff --git a/src/MsgPack/Serialization/BindingOptions.cs b/src/MsgPack/Serialization/BindingOptions.cs
index 29090576d..f0b2fd696 100644
--- a/src/MsgPack/Serialization/BindingOptions.cs
+++ b/src/MsgPack/Serialization/BindingOptions.cs
@@ -1,25 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2016 FUJIWARA, Yusuke and contributors
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// Contributors:
-//    Shrenik Jhaveri (ShrenikOne)
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
@@ -42,17 +23,17 @@ public class BindingOptions
 		/// </summary>
 		/// <param name="targetType">Type of the target.</param>
 		/// <param name="memberSkipList">The member skip list.</param>
-		public void SetIgnoringMembers( Type targetType, IEnumerable<string> memberSkipList )
+		public void SetIgnoringMembers(Type targetType, IEnumerable<string> memberSkipList)
 		{
-			lock ( this._typeIgnoringMembersMap )
+			lock (this._typeIgnoringMembersMap)
 			{
-				if ( this._typeIgnoringMembersMap.ContainsKey( targetType ) )
+				if (this._typeIgnoringMembersMap.ContainsKey(targetType))
 				{
-					this._typeIgnoringMembersMap[ targetType ] = memberSkipList;
+					this._typeIgnoringMembersMap[targetType] = memberSkipList;
 				}
 				else
 				{
-					this._typeIgnoringMembersMap.Add( targetType, memberSkipList );
+					this._typeIgnoringMembersMap.Add(targetType, memberSkipList);
 				}
 			}
 		}
@@ -62,13 +43,13 @@ public void SetIgnoringMembers( Type targetType, IEnumerable<string> memberSkipL
 		/// </summary>
 		/// <param name="targetType">Type of the target.</param>
 		/// <returns>Returns member skip list for a specific target type.</returns>
-		public IEnumerable<string> GetIgnoringMembers( Type targetType )
+		public IEnumerable<string> GetIgnoringMembers(Type targetType)
 		{
-			lock ( this._typeIgnoringMembersMap )
+			lock (this._typeIgnoringMembersMap)
 			{
-				if ( this._typeIgnoringMembersMap.ContainsKey( targetType ) )
+				if (this._typeIgnoringMembersMap.ContainsKey(targetType))
 				{
-					return this._typeIgnoringMembersMap[ targetType ];
+					return this._typeIgnoringMembersMap[targetType];
 				}
 				else
 				{
@@ -83,9 +64,9 @@ public IEnumerable<string> GetIgnoringMembers( Type targetType )
 		/// <returns>Returns all registered types specific ignoring members.</returns>
 		public IDictionary<Type, IEnumerable<string>> GetAllIgnoringMembers()
 		{
-			lock ( this._typeIgnoringMembersMap )
+			lock (this._typeIgnoringMembersMap)
 			{
-				return this._typeIgnoringMembersMap.ToDictionary( item => item.Key, item => ( IEnumerable<string> )item.Value.ToArray() );
+				return this._typeIgnoringMembersMap.ToDictionary(item => item.Key, item => (IEnumerable<string>)item.Value.ToArray());
 			}
 		}
 	}
diff --git a/src/MsgPack/Serialization/CollectionDetailedKind.cs b/src/MsgPack/Serialization/CollectionDetailedKind.cs
index d35962f82..a3cd59df0 100644
--- a/src/MsgPack/Serialization/CollectionDetailedKind.cs
+++ b/src/MsgPack/Serialization/CollectionDetailedKind.cs
@@ -1,37 +1,10 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
-
-using System;
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack.Serialization
 {
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	enum CollectionDetailedKind
+	internal enum CollectionDetailedKind
 	{
 		NotCollection = 0,
 		Array,
@@ -39,18 +12,18 @@ enum CollectionDetailedKind
 		NonGenericList,
 		GenericDictionary,
 		NonGenericDictionary,
-#if !NET35 && !UNITY
+#if !NET35
 		GenericSet,
-#endif // !NET35 && !UNITY
+#endif // !NET35
 		GenericCollection,
 		NonGenericCollection,
 		GenericEnumerable,
 		NonGenericEnumerable,
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+#if !NET35 && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
 		GenericReadOnlyList,
 		GenericReadOnlyCollection,
 		GenericReadOnlyDictionary,
-#endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+#endif // !NET35 && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
 		Unserializable
 	}
 }
diff --git a/src/MsgPack/Serialization/CollectionKind.cs b/src/MsgPack/Serialization/CollectionKind.cs
index 4072c364b..31e2dbe7c 100644
--- a/src/MsgPack/Serialization/CollectionKind.cs
+++ b/src/MsgPack/Serialization/CollectionKind.cs
@@ -1,37 +1,10 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
-
-using System;
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack.Serialization
 {
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	enum CollectionKind
+	internal enum CollectionKind
 	{
 		NotCollection = 0,
 		Array,
diff --git a/src/MsgPack/Serialization/CollectionTraitOptions.cs b/src/MsgPack/Serialization/CollectionTraitOptions.cs
index 8c11b59a2..6113c0d9b 100644
--- a/src/MsgPack/Serialization/CollectionTraitOptions.cs
+++ b/src/MsgPack/Serialization/CollectionTraitOptions.cs
@@ -1,30 +1,12 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2016 FUJIWARA, Yusuke and contributors
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// Contributors:
-//    Samuel Cragg
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
 namespace MsgPack.Serialization
 {
+#warning TODO: NonPublic
 	[Flags]
 	internal enum CollectionTraitOptions
 	{
@@ -32,7 +14,8 @@ internal enum CollectionTraitOptions
 		WithAddMethod = 0x1,
 		WithCountPropertyGetter = 0x2,
 		WithGetEnumeratorMethod = 0x4,
+		WithConstructor = 0x8,
 		AllowNonCollectionEnumerableTypes = 0x800,
-		Full = WithAddMethod | WithCountPropertyGetter | WithGetEnumeratorMethod
+		Full = WithAddMethod | WithCountPropertyGetter | WithGetEnumeratorMethod | WithConstructor
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/CollectionTraits.cs b/src/MsgPack/Serialization/CollectionTraits.cs
index 8496d1107..470114353 100644
--- a/src/MsgPack/Serialization/CollectionTraits.cs
+++ b/src/MsgPack/Serialization/CollectionTraits.cs
@@ -1,57 +1,35 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Reflection;
 
 namespace MsgPack.Serialization
 {
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	struct CollectionTraits
+	internal readonly struct CollectionTraits
 	{
-		public static readonly CollectionTraits NotCollection = new CollectionTraits( CollectionDetailedKind.NotCollection, null, null, null, null );
-		public static readonly CollectionTraits Unserializable = new CollectionTraits( CollectionDetailedKind.Unserializable, null, null, null, null );
+		public static readonly CollectionTraits NotCollection = new CollectionTraits(CollectionDetailedKind.NotCollection, null, null, null, null, null, null);
+		public static readonly CollectionTraits Unserializable = new CollectionTraits(CollectionDetailedKind.Unserializable, null, null, null, null, null, null);
 
-		public readonly Type ElementType;
+		public Type? ElementType { get; }
 
-		public readonly CollectionDetailedKind DetailedCollectionType;
+		public CollectionDetailedKind DetailedCollectionType { get; }
 
 		public CollectionKind CollectionType
 		{
 			get
 			{
-				switch ( this.DetailedCollectionType )
+				switch (this.DetailedCollectionType)
 				{
 					case CollectionDetailedKind.Array:
 					case CollectionDetailedKind.GenericCollection:
 					case CollectionDetailedKind.GenericEnumerable:
 					case CollectionDetailedKind.GenericList:
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
 					case CollectionDetailedKind.GenericReadOnlyCollection:
 					case CollectionDetailedKind.GenericReadOnlyList:
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
@@ -65,7 +43,7 @@ public CollectionKind CollectionType
 						return CollectionKind.Array;
 					}
 					case CollectionDetailedKind.GenericDictionary:
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
 					case CollectionDetailedKind.GenericReadOnlyDictionary:
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
 					case CollectionDetailedKind.NonGenericDictionary:
@@ -82,23 +60,49 @@ public CollectionKind CollectionType
 					}
 					default:
 					{
-						throw new NotSupportedException( "Unknown detailed type:" + this.DetailedCollectionType );
+						throw new NotSupportedException("Unknown detailed type:" + this.DetailedCollectionType);
 					}
 				}
 			}
 		}
 
-		public readonly MethodInfo GetEnumeratorMethod;
-		public readonly MethodInfo AddMethod;
-		public readonly MethodInfo CountPropertyGetter;
+		public MethodInfo? GetEnumeratorMethod { get; }
+		public MethodInfo? AddMethod { get; }
+		public MethodInfo? CountPropertyGetter { get; }
+
+		public ConstructorInfo? ConstructorWithCapacity { get; }
+		public ConstructorInfo? DefaultConstructor { get; }
 
-		public CollectionTraits( CollectionDetailedKind type, Type elementType, MethodInfo getEnumeratorMethod, MethodInfo addMethod, MethodInfo countPropertyGetter )
+		public CollectionTraits(CollectionDetailedKind type, ConstructorInfo? constructorWithCapacity, ConstructorInfo? defaultConstructor, Type? elementType, MethodInfo? getEnumeratorMethod, MethodInfo? addMethod, MethodInfo? countPropertyGetter)
 		{
 			this.DetailedCollectionType = type;
 			this.ElementType = elementType;
 			this.GetEnumeratorMethod = getEnumeratorMethod;
 			this.AddMethod = addMethod;
 			this.CountPropertyGetter = countPropertyGetter;
+			this.ConstructorWithCapacity = constructorWithCapacity;
+			this.DefaultConstructor = defaultConstructor;
+		}
+
+		public (Type? KeyType, Type? ValueType) GetKeyValueType()
+		{
+			if (this.ElementType == null || this.CollectionType != CollectionKind.Map)
+			{
+				return (null, null);
+			}
+
+			if (this.ElementType == typeof(DictionaryEntry))
+			{
+				return (typeof(object), typeof(object));
+			}
+
+			Debug.Assert(this.ElementType.IsGenericType, $"this.ElementType.IsGenericType ({this.ElementType})");
+			Debug.Assert(this.ElementType.GetGenericTypeDefinition() == typeof(KeyValuePair<,>), $"this.ElementType.GetGenericTypeDefinition()({this.ElementType}) == typeof(KeyValuePair<,>)");
+
+			var typeArguments = this.ElementType.GetGenericTypeParameters();
+			Debug.Assert(typeArguments.Length == 2, $"typeArguments.Length ({typeArguments.Length}) == 2");
+
+			return (typeArguments[0], typeArguments[1]);
 		}
 	}
 }
diff --git a/src/MsgPack/Serialization/DataMemberContract.cs b/src/MsgPack/Serialization/DataMemberContract.cs
index 8ff6f5abc..bdab6b1a0 100644
--- a/src/MsgPack/Serialization/DataMemberContract.cs
+++ b/src/MsgPack/Serialization/DataMemberContract.cs
@@ -1,33 +1,13 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 #if FEATURE_MPCONTRACT
 using Contract = MsgPack.MPContract;
 #else
 using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT || NETSTANDARD1_1
+#endif // FEATURE_MPCONTRACT
 using System.Globalization;
 using System.Reflection;
 using System.Runtime.Serialization;
@@ -37,48 +17,17 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Represents member's data contract.
 	/// </summary>
-#if !UNITY
-	internal struct DataMemberContract
-#else
-#warning TODO: To struct if possible
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	sealed class DataMemberContract
-#endif // !UNITY
+	internal readonly struct DataMemberContract
 	{
-#if UNITY
-		/// <summary>
-		///		Null object.
-		/// </summary>
-		public static readonly DataMemberContract Null = new DataMemberContract();
-#endif
-
 		internal const int UnspecifiedId = -1;
 
-		private readonly string _name;
-
 		/// <summary>
 		///		Gets the name of the member.
 		/// </summary>
 		/// <value>
 		///		The name of the member.
 		/// </value>
-		public string Name
-		{
-			get
-			{
-#if DEBUG
-				Contract.Ensures( !String.IsNullOrEmpty( Contract.Result<string>() ) );
-#endif // DEBUG
-
-				return this._name;
-			}
-		}
-
-		private readonly int _id;
+		public string Name { get; }
 
 		/// <summary>
 		///		Gets the ID of the member.
@@ -86,19 +35,7 @@ public string Name
 		/// <value>
 		///		The ID of the member. Default is <c>-1</c>.
 		/// </value>
-		public int Id
-		{
-			get
-			{
-#if DEBUG
-				Contract.Ensures( Contract.Result<int>() >= -1 );
-#endif // DEBUG
-
-				return this._id;
-			}
-		}
-
-		private readonly NilImplication _nilImplication;
+		public int Id { get; }
 
 		/// <summary>
 		///		Gets the nil implication.
@@ -106,31 +43,19 @@ public int Id
 		/// <value>
 		///		The nil implication.
 		/// </value>
-		public NilImplication NilImplication
-		{
-			get { return this._nilImplication; }
-		}
-
-#if UNITY
-		public DataMemberContract()
-		{
-			this._name = null;
-			this._nilImplication = NilImplication.MemberDefault;
-			this._id = UnspecifiedId;
-		}
-#endif // UNITY
+		public NilImplication NilImplication { get; }
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="DataMemberContract"/> struct.
 		/// </summary>
 		/// <param name="member">The target member.</param>
-		public DataMemberContract( MemberInfo member )
+		public DataMemberContract(MemberInfo member)
 		{
-			Contract.Assert( member != null );
+			Contract.Assert(member != null);
 
-			this._name = member.Name;
-			this._nilImplication = NilImplication.MemberDefault;
-			this._id = UnspecifiedId;
+			this.Name = member.Name;
+			this.NilImplication = NilImplication.MemberDefault;
+			this.Id = UnspecifiedId;
 		}
 
 		/// <summary>
@@ -140,18 +65,18 @@ public DataMemberContract( MemberInfo member )
 		/// <param name="name">The name of member.</param>
 		/// <param name="nilImplication">The implication of the nil value for the member.</param>
 		/// <param name="id">The ID of the member. This value cannot be negative and must be unique in the type.</param>
-		public DataMemberContract( MemberInfo member, string name, NilImplication nilImplication, int? id )
+		public DataMemberContract(MemberInfo member, string? name, NilImplication nilImplication, int? id)
 		{
-			Contract.Assert( member != null );
+			Contract.Assert(member != null);
 
-			if ( id < 0 )
+			if (id < 0)
 			{
-				throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The member ID cannot be negative. The member is '{0}' in the '{1}' type.", member.Name, member.DeclaringType ) );
+				throw new SerializationException(String.Format(CultureInfo.CurrentCulture, "The member ID cannot be negative. The member is '{0}' in the '{1}' type.", member.Name, member.DeclaringType));
 			}
 
-			this._name = String.IsNullOrEmpty( name ) ? member.Name : name;
-			this._nilImplication = nilImplication;
-			this._id = id ?? UnspecifiedId;
+			this.Name = String.IsNullOrEmpty(name) ? member.Name : name;
+			this.NilImplication = nilImplication;
+			this.Id = id ?? UnspecifiedId;
 		}
 
 		/// <summary>
@@ -159,19 +84,19 @@ public DataMemberContract( MemberInfo member, string name, NilImplication nilImp
 		/// </summary>
 		/// <param name="member">The target member.</param>
 		/// <param name="attribute">The MessagePack member attribute.</param>
-		public DataMemberContract( MemberInfo member, MessagePackMemberAttribute attribute )
+		public DataMemberContract(MemberInfo member, MessagePackMemberAttribute attribute)
 		{
-			Contract.Assert( member != null );
-			Contract.Assert( attribute != null );
+			Contract.Assert(member != null);
+			Contract.Assert(attribute != null);
 
-			if ( attribute.Id < 0 )
+			if (attribute.Id < 0)
 			{
-				throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "The member ID cannot be negative. The member is '{0}' in the '{1}' type.", member.Name, member.DeclaringType ) );
+				throw new SerializationException(String.Format(CultureInfo.CurrentCulture, "The member ID cannot be negative. The member is '{0}' in the '{1}' type.", member.Name, member.DeclaringType));
 			}
 
-			this._name = String.IsNullOrEmpty( attribute.Name ) ? member.Name : attribute.Name;
-			this._nilImplication = attribute.NilImplication;
-			this._id = attribute.Id;
+			this.Name = String.IsNullOrEmpty(attribute.Name) ? member.Name : attribute.Name;
+			this.NilImplication = attribute.NilImplication;
+			this.Id = attribute.Id;
 		}
 	}
 }
diff --git a/src/MsgPack/Serialization/DateTimeConversionMethod.cs b/src/MsgPack/Serialization/DateTimeConversionMethod.cs
index 47e82fac8..9f317fda5 100644
--- a/src/MsgPack/Serialization/DateTimeConversionMethod.cs
+++ b/src/MsgPack/Serialization/DateTimeConversionMethod.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
diff --git a/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs b/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs
index 27dd26a69..8ade1933b 100644
--- a/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs
+++ b/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
diff --git a/src/MsgPack/Serialization/EnumMemberSerializationMethod.cs b/src/MsgPack/Serialization/EnumMemberSerializationMethod.cs
index c605f80a2..40d1fcb96 100644
--- a/src/MsgPack/Serialization/EnumMemberSerializationMethod.cs
+++ b/src/MsgPack/Serialization/EnumMemberSerializationMethod.cs
@@ -1,24 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-using System;
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack.Serialization
 {
@@ -42,4 +24,4 @@ public enum EnumMemberSerializationMethod
 		/// </summary>
 		ByUnderlyingValue
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/EnumSerializationMethod.cs b/src/MsgPack/Serialization/EnumSerializationMethod.cs
index 13c75dd5b..ed2ab1839 100644
--- a/src/MsgPack/Serialization/EnumSerializationMethod.cs
+++ b/src/MsgPack/Serialization/EnumSerializationMethod.cs
@@ -1,24 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-using System;
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack.Serialization
 {
@@ -37,4 +19,4 @@ public enum EnumSerializationMethod
 		/// </summary>
 		ByUnderlyingValue
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/EnumSerializationOptions.cs b/src/MsgPack/Serialization/EnumSerializationOptions.cs
index 369fb46cd..8e6bd8e5c 100644
--- a/src/MsgPack/Serialization/EnumSerializationOptions.cs
+++ b/src/MsgPack/Serialization/EnumSerializationOptions.cs
@@ -18,10 +18,6 @@
 //
 #endregion -- License Terms --
 
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
-
 using System;
 #if FEATURE_MPCONTRACT
 using Contract = MsgPack.MPContract;
@@ -63,11 +59,11 @@ public EnumSerializationMethod SerializationMethod
 				Contract.Ensures( Enum.IsDefined( typeof( EnumSerializationMethod ), Contract.Result<EnumSerializationMethod>() ) );
 #endif // DEBUG
 
-				return ( EnumSerializationMethod )Volatile.Read( ref this._serializationMethod );
+				return (EnumSerializationMethod)Volatile.Read(ref this._serializationMethod);
 			}
 			set
 			{
-				switch ( value )
+				switch (value)
 				{
 					case EnumSerializationMethod.ByName:
 					case EnumSerializationMethod.ByUnderlyingValue:
@@ -76,13 +72,13 @@ public EnumSerializationMethod SerializationMethod
 					}
 					default:
 					{
-						throw new ArgumentOutOfRangeException( "value" );
+						throw new ArgumentOutOfRangeException("value");
 					}
 				}
 
 				Contract.EndContractBlock();
 
-				Volatile.Write( ref this._serializationMethod, ( int )value );
+				Volatile.Write(ref this._serializationMethod, (int)value);
 			}
 		}
 
@@ -126,4 +122,4 @@ internal Func<string, string> SafeNameTransformer
 			get { return this.NameTransformer ?? KeyNameTransformers.AsIs; }
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs
index 07c5b5911..484cfeebc 100644
--- a/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -28,7 +12,7 @@ namespace MsgPack.Serialization
 	/// <remarks>
 	///		If this attributes is used for incompatible typed members, this attribute will be ignored.
 	/// </remarks>
-	[AttributeUsage( AttributeTargets.Field | AttributeTargets.Property, Inherited = true, AllowMultiple = false )]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
 	public sealed class MessagePackDateTimeMemberAttribute : Attribute
 	{
 		/// <summary>
@@ -45,4 +29,4 @@ public sealed class MessagePackDateTimeMemberAttribute : Attribute
 		/// </summary>
 		public MessagePackDateTimeMemberAttribute() { }
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/MessagePackDeserializationConstructorAttribute.cs b/src/MsgPack/Serialization/MessagePackDeserializationConstructorAttribute.cs
index 734d0783d..23b4ea739 100644
--- a/src/MsgPack/Serialization/MessagePackDeserializationConstructorAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackDeserializationConstructorAttribute.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-// 
-// MessagePack for CLI
-// 
-// Copyright (C) 2015-2015 FUJIWARA, Yusuke
-// 
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-// 
-//        http://www.apache.org/licenses/LICENSE-2.0
-// 
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-// 
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -63,4 +47,4 @@ public sealed class MessagePackDeserializationConstructorAttribute : Attribute
 		/// </summary>
 		public MessagePackDeserializationConstructorAttribute() { }
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/MessagePackEnumAttribute.cs b/src/MsgPack/Serialization/MessagePackEnumAttribute.cs
index 8ce3551e3..05c3ccf9c 100644
--- a/src/MsgPack/Serialization/MessagePackEnumAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackEnumAttribute.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -28,7 +12,7 @@ namespace MsgPack.Serialization
 	/// <remarks>
 	///		Enum types which are not marked with this attribute will be serialized as <see cref="SerializationContext.EnumSerializationMethod"/> value.
 	/// </remarks>
-	[AttributeUsage( AttributeTargets.Enum, Inherited = false, AllowMultiple = false )]
+	[AttributeUsage(AttributeTargets.Enum, Inherited = false, AllowMultiple = false)]
 	public sealed class MessagePackEnumAttribute : Attribute
 	{
 		/// <summary>
@@ -45,4 +29,4 @@ public sealed class MessagePackEnumAttribute : Attribute
 		/// </summary>
 		public MessagePackEnumAttribute() { }
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs
index 530161c20..7a9f4661f 100644
--- a/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -28,7 +12,7 @@ namespace MsgPack.Serialization
 	/// <remarks>
 	///		If this attributes is used for non-enum typed members, this attribute will be ignored.
 	/// </remarks>
-	[AttributeUsage( AttributeTargets.Field | AttributeTargets.Property, Inherited = true, AllowMultiple = false )]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
 	public sealed class MessagePackEnumMemberAttribute : Attribute
 	{
 		/// <summary>
@@ -45,4 +29,4 @@ public sealed class MessagePackEnumMemberAttribute : Attribute
 		/// </summary>
 		public MessagePackEnumMemberAttribute() { }
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/MessagePackIgnoreAttribute.cs b/src/MsgPack/Serialization/MessagePackIgnoreAttribute.cs
index 3e3254317..9167bc8aa 100644
--- a/src/MsgPack/Serialization/MessagePackIgnoreAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackIgnoreAttribute.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -25,7 +9,7 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Marks the field or the property should not be serialized/deserialized with MessagePack for CLI serialization mechanism.
 	/// </summary>
-	[AttributeUsage( AttributeTargets.Field | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
 	public sealed class MessagePackIgnoreAttribute : Attribute
 	{
 		/// <summary>
diff --git a/src/MsgPack/Serialization/MessagePackMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackMemberAttribute.cs
index 2a8a78457..a5608da56 100644
--- a/src/MsgPack/Serialization/MessagePackMemberAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackMemberAttribute.cs
@@ -1,26 +1,7 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
 
 using System;
 #if FEATURE_MPCONTRACT
@@ -34,23 +15,16 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Marks a field or a property to be serialized with MessagePack Serializer and defines some required informations to serialize.
 	/// </summary>
-	[AttributeUsage( AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true )]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
 	public sealed class MessagePackMemberAttribute : Attribute
 	{
-		private readonly int _id;
-
 		/// <summary>
 		///		Gets the ID of the member.
 		/// </summary>
 		/// <value>
 		///		The ID of the member.
 		/// </value>
-		public int Id
-		{
-			get { return this._id; }
-		}
-
-		private string _name;
+		public int Id { get; }
 
 		/// <summary>
 		///		Gets or sets the name of this member.
@@ -58,11 +32,7 @@ public int Id
 		/// <value>
 		///		The name which will be used in map key on serialized MessagePack stream.
 		/// </value>
-		public string Name
-		{
-			get { return this._name; }
-			set { this._name = value; }
-		}
+		public string? Name { get; set; }
 
 		private NilImplication _nilImplication;
 
@@ -85,7 +55,7 @@ public NilImplication NilImplication
 			}
 			set
 			{
-				switch ( value )
+				switch (value)
 				{
 					case NilImplication.MemberDefault:
 					case NilImplication.Null:
@@ -95,7 +65,7 @@ public NilImplication NilImplication
 					}
 					default:
 					{
-						throw new ArgumentOutOfRangeException( "value" );
+						throw new ArgumentOutOfRangeException(nameof(value));
 					}
 				}
 
@@ -111,9 +81,9 @@ public NilImplication NilImplication
 		/// <param name="id">
 		///		The ID of the member. This value cannot be negative and must be unique in the type.
 		///	</param>
-		public MessagePackMemberAttribute( int id )
+		public MessagePackMemberAttribute(int id)
 		{
-			this._id = id;
+			this.Id = id;
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/NilImplication.cs b/src/MsgPack/Serialization/NilImplication.cs
index c338304c5..8fb9501c6 100644
--- a/src/MsgPack/Serialization/NilImplication.cs
+++ b/src/MsgPack/Serialization/NilImplication.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2012 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
diff --git a/src/MsgPack/Serialization/Polymorphic/IPolymorphicDeserializer.cs b/src/MsgPack/Serialization/Polymorphic/IPolymorphicDeserializer.cs
index 26f96d1fa..77d935007 100644
--- a/src/MsgPack/Serialization/Polymorphic/IPolymorphicDeserializer.cs
+++ b/src/MsgPack/Serialization/Polymorphic/IPolymorphicDeserializer.cs
@@ -19,9 +19,12 @@
 #endregion -- License Terms --
 
 using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
 #if FEATURE_TAP
 using System.Threading;
 using System.Threading.Tasks;
+using MsgPack.Internal;
 #endif // FEATURE_TAP
 
 namespace MsgPack.Serialization.Polymorphic
@@ -31,10 +34,20 @@ namespace MsgPack.Serialization.Polymorphic
 	/// </summary>
 	internal interface IPolymorphicDeserializer
 	{
-		object PolymorphicUnpackFrom( Unpacker unpacker );
+		object? DeserializePolymorphic(ref DeserializationOperationContext context, ref SequenceReader<byte> reader);
 
 #if FEATURE_TAP
-		Task<object> PolymorphicUnpackFromAsync( Unpacker unpacker, CancellationToken cancellationToken );
+		ValueTask<object?> DeserializePolymorphicAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence sequence, CancellationToken cancellationToken );
 #endif // FEATURE_TAP
 	}
-}
\ No newline at end of file
+
+#warning TODO: Compat
+	//internal static class PolymorphicDeserializerCompatibilityExtensions
+	//{
+	//	public static object PolymorphicUnpackFrom(this IPolymorphicDeserializer deserializer, Unpacker unpacker)
+	//		=> deserializer.DeserializePolymorphic(unpacker.Sequence);
+
+	//	public static ValueTask<object> PolymorphicUnpackFromAsync(this IPolymorphicDeserializer deserializer, Unpacker unpacker)
+	//		=> deserializer.PolymorphicDeserializeAsync(unpacker.Stream);
+	//}
+}
diff --git a/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs b/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs
index df29d8e02..62da7a124 100644
--- a/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs
+++ b/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs
@@ -1,31 +1,11 @@
-#region -- License Terms --
-//  MessagePack for CLI
-// 
-//  Copyright (C) 2015-2018 FUJIWARA, Yusuke and contributors
-// 
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-// 
-//         http://www.apache.org/licenses/LICENSE-2.0
-// 
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
-// Contributors:
-//    Samuel Cragg
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Diagnostics;
 #if FEATURE_MPCONTRACT
 using Contract = MsgPack.MPContract;
 #else
@@ -46,78 +26,73 @@ partial class PolymorphismSchema
 		private static readonly Func<PolymorphicTypeVerificationContext, bool> DefaultTypeVerfiier = _ => true;
 
 		/// <summary>
-		///		Default instance (null object).
+		///		Gets a default instance.
 		/// </summary>
-#if UNITY && DEBUG
-		public
-#else
-		internal
-#endif
-		static readonly PolymorphismSchema Default = new PolymorphismSchema();
+		public static PolymorphismSchema Default { get; } = new PolymorphismSchema();
 
 		/// <summary>
 		///		ForPolymorphicObject( Type targetType )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicObjectTypeEmbeddingMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicObject", new[] { typeof( Type ) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicObject", new[] { typeof(Type) });
 
 		/// <summary>
 		///		ForPolymorphicObject( Type targetType, IDictionary{byte, Type} codeTypeMapping )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicObjectCodeTypeMappingMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicObject", new[] { typeof( Type ), typeof( IDictionary<string, Type> ) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicObject", new[] { typeof(Type), typeof(IDictionary<string, Type>) });
 
 		/// <summary>
 		///		ForContextSpecifiedCollection( Type targetType, PolymorphismSchema itemsSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForContextSpecifiedCollectionMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForContextSpecifiedCollection", new[] { typeof( Type ), typeof( PolymorphismSchema ) } );
+			typeof(PolymorphismSchema).GetMethod("ForContextSpecifiedCollection", new[] { typeof(Type), typeof(PolymorphismSchema) });
 
 		/// <summary>
 		///		ForPolymorphicCollection( Type targetType, PolymorphismSchema itemsSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicCollectionTypeEmbeddingMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicCollection", new[] { typeof( Type ), typeof( PolymorphismSchema ) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicCollection", new[] { typeof(Type), typeof(PolymorphismSchema) });
 
 		/// <summary>
 		///		ForPolymorphicCollection( Type targetType, IDictionary{byte, Type} codeTypeMapping, PolymorphismSchema itemsSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicCollectionCodeTypeMappingMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicCollection", new[] { typeof( Type ), typeof( IDictionary<string, Type> ), typeof( PolymorphismSchema ) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicCollection", new[] { typeof(Type), typeof(IDictionary<string, Type>), typeof(PolymorphismSchema) });
 
 		/// <summary>
 		///		ForContextSpecifiedDictionary( Type targetType, PolymorphismSchema keysSchema, PolymorphismSchema valuesSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForContextSpecifiedDictionaryMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForContextSpecifiedDictionary", new[] { typeof( Type ), typeof( PolymorphismSchema ), typeof( PolymorphismSchema ) } );
+			typeof(PolymorphismSchema).GetMethod("ForContextSpecifiedDictionary", new[] { typeof(Type), typeof(PolymorphismSchema), typeof(PolymorphismSchema) });
 
 		/// <summary>
 		///		ForPolymorphicDictionary( Type targetType, PolymorphismSchema keysSchema, PolymorphismSchema valuesSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicDictionaryTypeEmbeddingMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicDictionary", new[] { typeof( Type ), typeof( PolymorphismSchema ), typeof( PolymorphismSchema ) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicDictionary", new[] { typeof(Type), typeof(PolymorphismSchema), typeof(PolymorphismSchema) });
 
 		/// <summary>
 		///		ForPolymorphicDictionary( Type targetType, IDictionary{byte, Type} codeTypeMapping, PolymorphismSchema keysSchema, PolymorphismSchema valuesSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicDictionaryCodeTypeMappingMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicDictionary", new[] { typeof( Type ), typeof( IDictionary<string, Type> ), typeof( PolymorphismSchema ), typeof( PolymorphismSchema ) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicDictionary", new[] { typeof(Type), typeof(IDictionary<string, Type>), typeof(PolymorphismSchema), typeof(PolymorphismSchema) });
 
 #if !NET35 && !UNITY
 		/// <summary>
 		///		ForPolymorphicTuple( Type targetType, PolymorphismSchema[] itemSchemaList )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicTupleMethod =
-			typeof( PolymorphismSchema ).GetMethod( "ForPolymorphicTuple", new[] { typeof( Type ), typeof( PolymorphismSchema[]) } );
+			typeof(PolymorphismSchema).GetMethod("ForPolymorphicTuple", new[] { typeof(Type), typeof(PolymorphismSchema[]) });
 #endif // !NET35 && !UNITY
 
 		internal static readonly ConstructorInfo CodeTypeMapConstructor =
-			typeof( Dictionary<,> ).MakeGenericType( typeof( string ), typeof( Type ) )
-				.GetConstructor( new[] { typeof( int ) } );
+			typeof(Dictionary<,>).MakeGenericType(typeof(string), typeof(Type))
+				.GetConstructor(new[] { typeof(int) });
 
 		internal static readonly MethodInfo AddToCodeTypeMapMethod =
-			typeof( Dictionary<,> ).MakeGenericType( typeof( string ), typeof( Type ) )
-				.GetMethod( "Add", new[] { typeof( string ), typeof( Type ) } );
+			typeof(Dictionary<,>).MakeGenericType(typeof(string), typeof(Type))
+				.GetMethod("Add", new[] { typeof(string), typeof(Type) });
 
 
 		internal string DebugString
@@ -125,50 +100,50 @@ internal string DebugString
 			get
 			{
 				var buffer = new StringBuilder();
-				this.ToDebugString( buffer );
+				this.ToDebugString(buffer);
 				return buffer.ToString();
 			}
 		}
 
-		private void ToDebugString( StringBuilder buffer )
+		private void ToDebugString(StringBuilder buffer)
 		{
-			buffer.Append( "{TargetType:" ).Append( this.TargetType ).Append( ", SchemaType:" ).Append( this.PolymorphismType );
-			switch ( this.ChildrenType )
+			buffer.Append("{TargetType:").Append(this.TargetType).Append(", SchemaType:").Append(this.PolymorphismType);
+			switch (this.ChildrenType)
 			{
 				case PolymorphismSchemaChildrenType.CollectionItems:
 				{
-					buffer.Append( ", CollectionItemsSchema:" );
-					if ( this.ItemSchema == null )
+					buffer.Append(", CollectionItemsSchema:");
+					if (this.ItemSchema == null)
 					{
-						buffer.Append( "null" );
+						buffer.Append("null");
 					}
 					else
 					{
-						this.ItemSchema.ToDebugString( buffer );
+						this.ItemSchema.ToDebugString(buffer);
 					}
 
 					break;
 				}
 				case PolymorphismSchemaChildrenType.DictionaryKeyValues:
 				{
-					buffer.Append( ", DictinoaryKeysSchema:" );
-					if ( this.KeySchema == null )
+					buffer.Append(", DictinoaryKeysSchema:");
+					if (this.KeySchema == null)
 					{
-						buffer.Append( "null" );
+						buffer.Append("null");
 					}
 					else
 					{
-						this.KeySchema.ToDebugString( buffer );
+						this.KeySchema.ToDebugString(buffer);
 					}
 
-					buffer.Append( ", DictinoaryValuesSchema:" );
-					if ( this.ItemSchema == null )
+					buffer.Append(", DictinoaryValuesSchema:");
+					if (this.ItemSchema == null)
 					{
-						buffer.Append( "null" );
+						buffer.Append("null");
 					}
 					else
 					{
-						this.ItemSchema.ToDebugString( buffer );
+						this.ItemSchema.ToDebugString(buffer);
 					}
 
 					break;
@@ -176,26 +151,26 @@ private void ToDebugString( StringBuilder buffer )
 #if !NET35 && !UNITY
 				case PolymorphismSchemaChildrenType.TupleItems:
 				{
-					buffer.Append( ", TupleItemsSchema:[" );
+					buffer.Append(", TupleItemsSchema:[");
 					var isFirst = true;
-					foreach ( var child in this._children )
+					foreach (var child in this._children)
 					{
-						if ( isFirst )
+						if (isFirst)
 						{
 							isFirst = false;
 						}
 						else
 						{
-							buffer.Append( ", " );
+							buffer.Append(", ");
 						}
 
-						if ( child == null )
+						if (child == null)
 						{
-							buffer.Append( "null" );
+							buffer.Append("null");
 						}
 						else
 						{
-							child.ToDebugString( buffer );
+							child.ToDebugString(buffer);
 						}
 					}
 
@@ -204,10 +179,11 @@ private void ToDebugString( StringBuilder buffer )
 #endif // !NET35 && !UNITY
 			}
 
-			buffer.Append( '}' );
+			buffer.Append('}');
 		}
 
 		internal static PolymorphismSchema Create(
+			DiagnosticSource diag,
 			Type type,
 #if !UNITY
 			SerializingMember? memberMayBeNull
@@ -216,31 +192,35 @@ SerializingMember memberMayBeNull
 #endif // !UNITY
 			)
 		{
-			if ( type.GetIsValueType() )
+			if (type.GetIsValueType())
 			{
-				SerializerDebugging.TracePolimorphicSchemaEvent(
-					"Returns default because '{0}' is value type: {1}",
-					memberMayBeNull == null
+				diag.DefaultPolymorphicSchemaForValueType(
+					new
+					{
+						targetType =
+							memberMayBeNull == null ?
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-					? type
+							type :
 #else
-					? type.GetTypeInfo()
+							type.GetTypeInfo() :
 #endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
 #if !UNITY
-					: memberMayBeNull.Value.Member,
+							memberMayBeNull.Value.Member,
 #else
-					: memberMayBeNull.Member,
+							memberMayBeNull.Member,
 #endif
-					Default
+						schema = Default
+					}
 				);
 				// Value types will never be polymorphic.
 				return Default;
 			}
 
-			if ( memberMayBeNull == null )
+			if (memberMayBeNull == null)
 			{
 				var schema =
 					CreateCore(
+						diag,
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
 						type,
 #else
@@ -248,14 +228,17 @@ SerializingMember memberMayBeNull
 #endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
 						Default
 					);
-				SerializerDebugging.TracePolimorphicSchemaEvent(
-					"Returns root type schema for '{0}': {1}",
+				diag.PolymorphicSchemaCreatedForRootType(
+					new
+					{
+						targetType =
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-					type,
+							type,
 #else
-					type.GetTypeInfo(),
+							type.GetTypeInfo(),
 #endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-					schema
+						schema = schema
+					}
 				);
 				return schema;
 			}
@@ -268,8 +251,10 @@ SerializingMember memberMayBeNull
 
 			return
 				CreateCore(
+					diag,
 					member.Member,
 					CreateCore(
+						diag,
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
 						type,
 #else
@@ -280,23 +265,32 @@ SerializingMember memberMayBeNull
 				);
 		}
 
-		private static PolymorphismSchema CreateCore( MemberInfo member, PolymorphismSchema defaultSchema )
+		private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo member, PolymorphismSchema defaultSchema)
 		{
-			var table = TypeTable.Create( member, defaultSchema );
+			var table = TypeTable.Create(member, defaultSchema);
 
-			var traits = member.GetMemberValueType().GetCollectionTraits( CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false );
-			switch ( traits.CollectionType )
+#warning TODO: CollectionTraits can be taken from SerializingMember.
+			var traits = member.GetMemberValueType().GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false);
+			switch (traits.CollectionType)
 			{
 				case CollectionKind.Array:
 				{
-					if ( !table.Member.Exists && !table.CollectionItem.Exists )
+					if (!table.Member.Exists && !table.CollectionItem.Exists)
 					{
-						SerializerDebugging.TracePolimorphicSchemaEvent( "Returns default because '{0}' does not have own nor items schema: {1}", member, defaultSchema );
+						diag.DefaultPolymorphicSchemaForUnqualifiedCollectionMember(
+							new
+							{
+								targetMember = member,
+								schema = defaultSchema
+							}
+						);
 						return defaultSchema;
 					}
 
-					SerializerDebugging.TracePolimorphicSchemaEvent( "Returns collection schema for '{0}': {1}", member, defaultSchema );
-					return
+					Debug.Assert(traits.ElementType != null, "traits.ElementType != null");
+
+#warning TODO: Non-Generic?
+					var result =
 						new PolymorphismSchema(
 							member.GetMemberValueType(),
 							table.Member.PolymorphismType,
@@ -311,17 +305,34 @@ private static PolymorphismSchema CreateCore( MemberInfo member, PolymorphismSch
 								PolymorphismSchemaChildrenType.None
 							)
 						);
+					diag.PolymorphicSchemaCreatedForCollectionMember(
+						new
+						{
+							targetMember = member,
+							schema = result
+						}
+					);
+					return result;
 				}
 				case CollectionKind.Map:
 				{
-					if ( !table.Member.Exists && !table.DictionaryKey.Exists && !table.CollectionItem.Exists )
+					if (!table.Member.Exists && !table.DictionaryKey.Exists && !table.CollectionItem.Exists)
 					{
-						SerializerDebugging.TracePolimorphicSchemaEvent( "Returns default because '{0}' does not have own, keys, nor items schema: {1}", member, defaultSchema );
+						diag.DefaultPolymorphicSchemaForUnqualifiedDictionaryMember(
+							new
+							{
+								targetMember = member,
+								schema = defaultSchema
+							}
+						);
 						return defaultSchema;
 					}
 
-					SerializerDebugging.TracePolimorphicSchemaEvent( "Returns dictionary schema for '{0}': {1}", member, defaultSchema );
-					return
+					Debug.Assert(traits.ElementType != null, "traits.ElementType != null");
+					var genericArguments = traits.ElementType.GetGenericArguments();
+
+#warning TODO: Non-Generic?
+					var result =
 						new PolymorphismSchema(
 							member.GetMemberValueType(),
 							table.Member.PolymorphismType,
@@ -329,35 +340,49 @@ private static PolymorphismSchema CreateCore( MemberInfo member, PolymorphismSch
 							table.Member.TypeVerifier,
 							PolymorphismSchemaChildrenType.DictionaryKeyValues,
 							new PolymorphismSchema(
-								traits.ElementType.GetGenericArguments()[ 0 ],
+								genericArguments[0],
 								table.DictionaryKey.PolymorphismType,
 								table.DictionaryKey.CodeTypeMapping,
 								table.DictionaryKey.TypeVerifier,
 								PolymorphismSchemaChildrenType.None
 							),
 							new PolymorphismSchema(
-								traits.ElementType.GetGenericArguments()[ 1 ],
+								genericArguments[1],
 								table.CollectionItem.PolymorphismType,
 								table.CollectionItem.CodeTypeMapping,
 								table.CollectionItem.TypeVerifier,
 								PolymorphismSchemaChildrenType.None
 							)
 						);
+
+					diag.PolymorphicSchemaCreatedForDictionaryMember(
+						new
+						{
+							targetMember = member,
+							schema = result
+						}
+					);
+					return result;
 				}
 				default:
 				{
 #if !NET35 && !UNITY
-					if ( TupleItems.IsTuple( member.GetMemberValueType() ) )
+					if (TupleItems.IsTuple(member.GetMemberValueType()))
 					{
-						if ( table.TupleItems.Count == 0 )
+						if (table.TupleItems.Count == 0)
 						{
-							SerializerDebugging.TracePolimorphicSchemaEvent( "Returns default because '{0}' does not have any tuple items schema: {1}", member, defaultSchema );
+							diag.DefaultPolymorphicSchemaForUnqualifiedTupleMember(
+								new
+								{
+									targetMember = member,
+									schema = defaultSchema
+								}
+							);
 							return defaultSchema;
 						}
 
-						var tupleItemTypes = TupleItems.GetTupleItemTypes( member.GetMemberValueType() );
-						SerializerDebugging.TracePolimorphicSchemaEvent( "Returns tuple items schema for '{0}': {1}", member, defaultSchema );
-						return
+						var tupleItemTypes = TupleItems.GetTupleItemTypes(member.GetMemberValueType());
+						var result =
 							new PolymorphismSchema(
 								member.GetMemberValueType(),
 								PolymorphismType.None,
@@ -365,29 +390,43 @@ private static PolymorphismSchema CreateCore( MemberInfo member, PolymorphismSch
 								DefaultTypeVerfiier,
 								PolymorphismSchemaChildrenType.TupleItems,
 								table.TupleItems
-								.Zip( tupleItemTypes, ( e, t ) => new { Entry = e, ItemType = t } )
-								.Select( e =>
-									new PolymorphismSchema(
-										e.ItemType,
-										e.Entry.PolymorphismType,
-										e.Entry.CodeTypeMapping,
-										e.Entry.TypeVerifier,
-										PolymorphismSchemaChildrenType.None
-									)
+								.Zip(tupleItemTypes, (e, t) => new { Entry = e, ItemType = t })
+								.Select(e =>
+								   new PolymorphismSchema(
+									   e.ItemType,
+									   e.Entry.PolymorphismType,
+									   e.Entry.CodeTypeMapping,
+									   e.Entry.TypeVerifier,
+									   PolymorphismSchemaChildrenType.None
+								   )
 								).ToArray()
 							);
+
+						diag.PolymorphicSchemaCreatedForTupleMember(
+							new
+							{
+								targetMember = member,
+								schema = result
+							}
+						);
+						return result;
 					}
 					else
 #endif // !NET35 && !UNITY
 					{
-						if ( !table.Member.Exists )
+						if (!table.Member.Exists)
 						{
-							SerializerDebugging.TracePolimorphicSchemaEvent( "Returns default because '{0}' does not have own schema: {1}", member, defaultSchema );
+							diag.DefaultPolymorphicSchemaForUnqualifiedObjectMember(
+								new
+								{
+									targetMember = member,
+									schema = defaultSchema
+								}
+							);
 							return defaultSchema;
 						}
 
-						SerializerDebugging.TracePolimorphicSchemaEvent( "Returns type of member schema for '{0}'.", member, defaultSchema );
-						return
+						var result =
 							new PolymorphismSchema(
 								member.GetMemberValueType(),
 								table.Member.PolymorphismType,
@@ -395,6 +434,14 @@ private static PolymorphismSchema CreateCore( MemberInfo member, PolymorphismSch
 								table.Member.TypeVerifier,
 								PolymorphismSchemaChildrenType.None
 							);
+						diag.PolymorphicSchemaCreatedForObjectMember(
+							new
+							{
+								targetMember = member,
+								schema = result
+							}
+						);
+						return result;
 					}
 				}
 			}
@@ -426,15 +473,15 @@ TypeTableEntry dictionaryKey
 #endif // !NET35 && !UNITY
 			}
 
-			public static TypeTable Create( MemberInfo member, PolymorphismSchema defaultSchema )
+			public static TypeTable Create(MemberInfo member, PolymorphismSchema defaultSchema)
 			{
 				return
 					new TypeTable(
-						TypeTableEntry.Create( member, PolymorphismTarget.Member, defaultSchema ),
-						TypeTableEntry.Create( member, PolymorphismTarget.CollectionItem, defaultSchema.TryGetItemSchema() ),
-						TypeTableEntry.Create( member, PolymorphismTarget.DictionaryKey, defaultSchema.TryGetKeySchema() )
+						TypeTableEntry.Create(member, PolymorphismTarget.Member, defaultSchema),
+						TypeTableEntry.Create(member, PolymorphismTarget.CollectionItem, defaultSchema.TryGetItemSchema()),
+						TypeTableEntry.Create(member, PolymorphismTarget.DictionaryKey, defaultSchema.TryGetKeySchema())
 #if !NET35 && !UNITY
-						, TypeTableEntry.CreateTupleItems( member )
+						, TypeTableEntry.CreateTupleItems(member)
 #endif // !NET35 && !UNITY
 					);
 			}
@@ -443,7 +490,7 @@ public static TypeTable Create( MemberInfo member, PolymorphismSchema defaultSch
 		private sealed class TypeTableEntry
 		{
 #if !NET35 && !UNITY
-			private static readonly TypeTableEntry[] EmptyEntries = new TypeTableEntry[ 0 ];
+			private static readonly TypeTableEntry[] EmptyEntries = new TypeTableEntry[0];
 #endif // !NET35 && !UNITY
 
 			private readonly Dictionary<string, Type> _knownTypeMapping = new Dictionary<string, Type>();
@@ -471,149 +518,149 @@ public PolymorphismType PolymorphismType
 
 			private TypeTableEntry() { }
 
-			public static TypeTableEntry Create( MemberInfo member, PolymorphismTarget targetType, PolymorphismSchema defaultSchema )
+			public static TypeTableEntry Create(MemberInfo member, PolymorphismTarget targetType, PolymorphismSchema defaultSchema)
 			{
 				var result = new TypeTableEntry();
 				var memberName = member.ToString();
 				foreach (
 					var attribute in
-						member.GetCustomAttributes( false )
+						member.GetCustomAttributes(false)
 							.OfType<IPolymorphicHelperAttribute>()
-							.Where( a => a.Target == targetType )
+							.Where(a => a.Target == targetType)
 				)
 				{
 					// TupleItem schema should never come here, so passing -1 as tupleItemNumber is OK.
-					result.Interpret( attribute, memberName, -1 );
+					result.Interpret(attribute, memberName, -1);
 				}
 
-				if ( defaultSchema != null )
+				if (defaultSchema != null)
 				{
 					// TupleItem schema should never come here, so passing -1 as tupleItemNumber is OK.
-					result.SetDefault( targetType, memberName, -1, defaultSchema );
+					result.SetDefault(targetType, memberName, -1, defaultSchema);
 				}
 
 				return result;
 			}
 
 #if !NET35 && !UNITY
-			public static TypeTableEntry[] CreateTupleItems( MemberInfo member )
+			public static TypeTableEntry[] CreateTupleItems(MemberInfo member)
 			{
-				if ( !TupleItems.IsTuple( member.GetMemberValueType() ) )
+				if (!TupleItems.IsTuple(member.GetMemberValueType()))
 				{
 					return EmptyEntries;
 				}
 
-				var tupleItems = TupleItems.GetTupleItemTypes( member.GetMemberValueType() );
-				var result = tupleItems.Select( _ => new TypeTableEntry() ).ToArray();
+				var tupleItems = TupleItems.GetTupleItemTypes(member.GetMemberValueType());
+				var result = tupleItems.Select(_ => new TypeTableEntry()).ToArray();
 				foreach (
 					var attribute in
-						member.GetCustomAttributes( false )
+						member.GetCustomAttributes(false)
 							.OfType<IPolymorphicTupleItemTypeAttribute>()
-							.OrderBy( a => a.ItemNumber )
+							.OrderBy(a => a.ItemNumber)
 				)
 				{
-					result[ attribute.ItemNumber - 1 ].Interpret( attribute, member.ToString(), attribute.ItemNumber );
+					result[attribute.ItemNumber - 1].Interpret(attribute, member.ToString(), attribute.ItemNumber);
 				}
 
 				return result;
 			}
 #endif // !NET35 && !UNITY
 
-			private void Interpret( IPolymorphicHelperAttribute attribute, string memberName, int tupleItemNumber )
+			private void Interpret(IPolymorphicHelperAttribute attribute, string memberName, int tupleItemNumber)
 			{
 				var asKnown = attribute as IPolymorphicKnownTypeAttribute;
-				if ( asKnown != null )
+				if (asKnown != null)
 				{
-					this.SetKnownType( attribute.Target, memberName, tupleItemNumber, asKnown.TypeCode, asKnown.BindingType );
+					this.SetKnownType(attribute.Target, memberName, tupleItemNumber, asKnown.TypeCode, asKnown.BindingType);
 					return;
 				}
 
 #if DEBUG
-				Contract.Assert( attribute is IPolymorphicRuntimeTypeAttribute, attribute + " is IPolymorphicRuntimeTypeAttribute" );
+				Contract.Assert(attribute is IPolymorphicRuntimeTypeAttribute, attribute + " is IPolymorphicRuntimeTypeAttribute");
 #endif // DEBUG
-				if ( this._useTypeEmbedding )
+				if (this._useTypeEmbedding)
 				{
 #if DEBUG
-					Contract.Assert( attribute.Target == PolymorphismTarget.TupleItem, attribute.Target + " == PolymorphismTarget.TupleItem" );
+					Contract.Assert(attribute.Target == PolymorphismTarget.TupleItem, attribute.Target + " == PolymorphismTarget.TupleItem");
 #endif // DEBUG
 					throw new SerializationException(
 						String.Format(
 							CultureInfo.CurrentCulture,
 							"Cannot specify multiple '{0}' to #{1} item of tuple type member '{2}'.",
-							typeof( MessagePackRuntimeTupleItemTypeAttribute ),
+							typeof(MessagePackRuntimeTupleItemTypeAttribute),
 							tupleItemNumber,
 							memberName
 						)
 					);
 				}
 
-				this.SetRuntimeType( attribute.Target, memberName, tupleItemNumber, GetVerifier( attribute as IPolymorphicRuntimeTypeAttribute ) );
+				this.SetRuntimeType(attribute.Target, memberName, tupleItemNumber, GetVerifier(attribute as IPolymorphicRuntimeTypeAttribute));
 			}
 
-			private void SetDefault( PolymorphismTarget target, string memberName, int tupleItemNumber, PolymorphismSchema defaultSchema )
+			private void SetDefault(PolymorphismTarget target, string memberName, int tupleItemNumber, PolymorphismSchema defaultSchema)
 			{
-				if ( this._useTypeEmbedding || this._knownTypeMapping.Count > 0 )
+				if (this._useTypeEmbedding || this._knownTypeMapping.Count > 0)
 				{
 					// Default is not required.
 					return;
 				}
 
-				switch ( defaultSchema.PolymorphismType )
+				switch (defaultSchema.PolymorphismType)
 				{
 					case PolymorphismType.KnownTypes:
 					{
-						foreach ( var typeMapping in defaultSchema.CodeTypeMapping )
+						foreach (var typeMapping in defaultSchema.CodeTypeMapping)
 						{
-							this.SetKnownType( target, memberName, tupleItemNumber, typeMapping.Key, typeMapping.Value );
+							this.SetKnownType(target, memberName, tupleItemNumber, typeMapping.Key, typeMapping.Value);
 						}
 
 						break;
 					}
 					case PolymorphismType.RuntimeType:
 					{
-						this.SetRuntimeType( target, memberName, tupleItemNumber, defaultSchema.TypeVerifier );
+						this.SetRuntimeType(target, memberName, tupleItemNumber, defaultSchema.TypeVerifier);
 						break;
 					}
 				}
 			}
 
-			private void SetKnownType( PolymorphismTarget target, string memberName, int tupleItemNumber, string typeCode, Type bindingType )
+			private void SetKnownType(PolymorphismTarget target, string memberName, int tupleItemNumber, string typeCode, Type bindingType)
 			{
-				if ( this._useTypeEmbedding )
+				if (this._useTypeEmbedding)
 				{
 					throw new SerializationException(
-						GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( target, memberName, tupleItemNumber )
+						GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage(target, memberName, tupleItemNumber)
 					);
 				}
 
 				try
 				{
-					this._knownTypeMapping.Add( typeCode, bindingType );
+					this._knownTypeMapping.Add(typeCode, bindingType);
 					this.TypeVerifier = DefaultTypeVerfiier;
 				}
-				catch ( ArgumentException )
+				catch (ArgumentException)
 				{
 					throw new SerializationException(
-						GetCannotDuplicateKnownTypeCodeErrorMessage( target, typeCode, memberName, tupleItemNumber )
+						GetCannotDuplicateKnownTypeCodeErrorMessage(target, typeCode, memberName, tupleItemNumber)
 					);
 				}
 			}
 
-			private void SetRuntimeType( PolymorphismTarget target, string memberName, int tupleItemNumber, Func<PolymorphicTypeVerificationContext, bool> typeVerifier )
+			private void SetRuntimeType(PolymorphismTarget target, string memberName, int tupleItemNumber, Func<PolymorphicTypeVerificationContext, bool> typeVerifier)
 			{
-				if ( this._knownTypeMapping.Count > 0 )
+				if (this._knownTypeMapping.Count > 0)
 				{
 					throw new SerializationException(
-						GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( target, memberName, tupleItemNumber )
+						GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage(target, memberName, tupleItemNumber)
 					);
 				}
 
 				this.TypeVerifier = typeVerifier;
 				this._useTypeEmbedding = true;
 			}
-			private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( PolymorphismTarget target, string memberName, int? tupleItemNumber )
+			private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage(PolymorphismTarget target, string memberName, int? tupleItemNumber)
 			{
-				switch ( target )
+				switch (target)
 				{
 					case PolymorphismTarget.CollectionItem:
 					{
@@ -621,8 +668,8 @@ private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( Polym
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify '{0}' and '{1}' simultaneously to collection items of member '{2}' itself.",
-								typeof( MessagePackRuntimeCollectionItemTypeAttribute ),
-								typeof( MessagePackKnownCollectionItemTypeAttribute ),
+								typeof(MessagePackRuntimeCollectionItemTypeAttribute),
+								typeof(MessagePackKnownCollectionItemTypeAttribute),
 								memberName
 							);
 					}
@@ -632,8 +679,8 @@ private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( Polym
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify '{0}' and '{1}' simultaneously to dictionary keys of member '{2}' itself.",
-								typeof( MessagePackRuntimeDictionaryKeyTypeAttribute ),
-								typeof( MessagePackKnownDictionaryKeyTypeAttribute ),
+								typeof(MessagePackRuntimeDictionaryKeyTypeAttribute),
+								typeof(MessagePackKnownDictionaryKeyTypeAttribute),
 								memberName
 							);
 					}
@@ -643,8 +690,8 @@ private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( Polym
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify '{0}' and '{1}' simultaneously to #{2} item of tuple type member '{3}' itself.",
-								typeof( MessagePackRuntimeTupleItemTypeAttribute ),
-								typeof( MessagePackKnownTupleItemTypeAttribute ),
+								typeof(MessagePackRuntimeTupleItemTypeAttribute),
+								typeof(MessagePackKnownTupleItemTypeAttribute),
 								tupleItemNumber,
 								memberName
 							);
@@ -655,17 +702,17 @@ private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage( Polym
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify '{0}' and '{1}' simultaneously to member '{2}' itself.",
-								typeof( MessagePackRuntimeTypeAttribute ),
-								typeof( MessagePackKnownTypeAttribute ),
+								typeof(MessagePackRuntimeTypeAttribute),
+								typeof(MessagePackKnownTypeAttribute),
 								memberName
 							);
 					}
 				}
 			}
 
-			private static string GetCannotDuplicateKnownTypeCodeErrorMessage( PolymorphismTarget target, string typeCode, string memberName, int tupleItemNumber )
+			private static string GetCannotDuplicateKnownTypeCodeErrorMessage(PolymorphismTarget target, string typeCode, string memberName, int tupleItemNumber)
 			{
-				switch ( target )
+				switch (target)
 				{
 					case PolymorphismTarget.CollectionItem:
 					{
@@ -673,7 +720,7 @@ private static string GetCannotDuplicateKnownTypeCodeErrorMessage( PolymorphismT
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify multiple types for ext-type code '{0}' for collection items of member '{1}'.",
-								StringEscape.ForDisplay( typeCode ),
+								StringEscape.ForDisplay(typeCode),
 								memberName
 							);
 					}
@@ -683,7 +730,7 @@ private static string GetCannotDuplicateKnownTypeCodeErrorMessage( PolymorphismT
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify multiple types for ext-type code '{0}' for dictionary keys of member '{1}'.",
-								StringEscape.ForDisplay( typeCode ),
+								StringEscape.ForDisplay(typeCode),
 								memberName
 							);
 					}
@@ -693,7 +740,7 @@ private static string GetCannotDuplicateKnownTypeCodeErrorMessage( PolymorphismT
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify multiple types for ext-type code '{0}' for #{1} item of tuple type member '{2}'.",
-								StringEscape.ForDisplay( typeCode ),
+								StringEscape.ForDisplay(typeCode),
 								tupleItemNumber,
 								memberName
 							);
@@ -704,57 +751,57 @@ private static string GetCannotDuplicateKnownTypeCodeErrorMessage( PolymorphismT
 							String.Format(
 								CultureInfo.CurrentCulture,
 								"Cannot specify multiple types for ext-type code '{0}' for member '{1}'.",
-								StringEscape.ForDisplay( typeCode ),
+								StringEscape.ForDisplay(typeCode),
 								memberName
 							);
 					}
 				}
 			}
 
-			private static Func<PolymorphicTypeVerificationContext, bool> GetVerifier( IPolymorphicRuntimeTypeAttribute attribute )
+			private static Func<PolymorphicTypeVerificationContext, bool> GetVerifier(IPolymorphicRuntimeTypeAttribute attribute)
 			{
-				if ( attribute.VerifierType == null )
+				if (attribute.VerifierType == null)
 				{
 					// Use default.
 					return DefaultTypeVerfiier;
 				}
 
-				if ( String.IsNullOrEmpty( attribute.VerifierMethodName ) )
+				if (String.IsNullOrEmpty(attribute.VerifierMethodName))
 				{
-					throw new SerializationException( "VerifierMethodName cannot be null nor empty if VerifierType is specified." );
+					throw new SerializationException("VerifierMethodName cannot be null nor empty if VerifierType is specified.");
 				}
 
 				// Explore [static] bool X(PolymorphicTypeVerificationContext)
-				var method = attribute.VerifierType.GetRuntimeMethods().SingleOrDefault( m => IsVerificationMethod( m, attribute.VerifierMethodName ) );
-				if ( method == null )
+				var method = attribute.VerifierType.GetRuntimeMethods().SingleOrDefault(m => IsVerificationMethod(m, attribute.VerifierMethodName));
+				if (method == null)
 				{
-					throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "A public static or instance method named '{0}' with single parameter typed PolymorphicTypeVerificationContext in type '{1}'.", attribute.VerifierMethodName, attribute.VerifierMethodName ) );
+					throw new SerializationException(String.Format(CultureInfo.CurrentCulture, "A public static or instance method named '{0}' with single parameter typed PolymorphicTypeVerificationContext in type '{1}'.", attribute.VerifierMethodName, attribute.VerifierMethodName));
 				}
 
-				if ( method.IsStatic )
+				if (method.IsStatic)
 				{
-					return method.CreateDelegate( typeof( Func<PolymorphicTypeVerificationContext, bool> ) ) as Func<PolymorphicTypeVerificationContext, bool>;
+					return method.CreateDelegate(typeof(Func<PolymorphicTypeVerificationContext, bool>)) as Func<PolymorphicTypeVerificationContext, bool>;
 				}
 				else
 				{
-					return method.CreateDelegate( typeof( Func<PolymorphicTypeVerificationContext, bool> ), Activator.CreateInstance( attribute.VerifierType ) ) as Func<PolymorphicTypeVerificationContext, bool>;
+					return method.CreateDelegate(typeof(Func<PolymorphicTypeVerificationContext, bool>), Activator.CreateInstance(attribute.VerifierType)) as Func<PolymorphicTypeVerificationContext, bool>;
 				}
 			}
 
-			private static bool IsVerificationMethod( MethodInfo method, string name )
+			private static bool IsVerificationMethod(MethodInfo method, string name)
 			{
-				if ( method.ReturnType != typeof( bool ) )
+				if (method.ReturnType != typeof(bool))
 				{
 					return false;
 				}
 
-				if ( method.Name != name )
+				if (method.Name != name)
 				{
 					return false;
 				}
 
 				var parameters = method.GetParameters();
-				return parameters.Length == 1 && parameters[ 0 ].ParameterType.IsAssignableFrom( typeof( PolymorphicTypeVerificationContext ) );
+				return parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(typeof(PolymorphicTypeVerificationContext));
 			}
 		}
 	}
diff --git a/src/MsgPack/Serialization/ReflectionExtensions.CollectionTraits.cs b/src/MsgPack/Serialization/ReflectionExtensions.CollectionTraits.cs
index 7ab397a1a..c4c87ff9f 100644
--- a/src/MsgPack/Serialization/ReflectionExtensions.CollectionTraits.cs
+++ b/src/MsgPack/Serialization/ReflectionExtensions.CollectionTraits.cs
@@ -1,29 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke and contributors
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// Contributors:
-//    Samuel Cragg
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
@@ -40,94 +17,101 @@
 
 namespace MsgPack.Serialization
 {
-	partial class ReflectionExtensions
+	internal partial class ReflectionExtensions
 	{
-		internal static CollectionTraits GetCollectionTraits( this Type source, CollectionTraitOptions options, bool allowNonCollectionEnumerableTypes )
+		private static readonly Type[] WithCapacityConstructorParameterTypes = new[] { typeof(int) };
+		private static readonly (ConstructorInfo? WithCapacity, ConstructorInfo? Default) ArrayListConstructors =
+			(typeof(ArrayList).GetConstructor(WithCapacityConstructorParameterTypes),
+			typeof(ArrayList).GetConstructor(ReflectionAbstractions.EmptyTypes));
+		private static readonly (ConstructorInfo? WithCapacity, ConstructorInfo? Default) HashtableConstructors =
+			(typeof(Hashtable).GetConstructor(WithCapacityConstructorParameterTypes),
+			typeof(Hashtable).GetConstructor(ReflectionAbstractions.EmptyTypes));
+
+		public static CollectionTraits GetCollectionTraits(this Type source, CollectionTraitOptions options, bool allowNonCollectionEnumerableTypes)
 		{
 #if DEBUG
-			Contract.Assert( !source.GetContainsGenericParameters(), "!source.GetContainsGenericParameters()" );
+			Contract.Assert(!source.GetContainsGenericParameters(), "!source.GetContainsGenericParameters()");
 #endif // DEBUG
 			/*
 			 * SPEC
-			 * If the object has single public method TEnumerator GetEnumerator() ( where TEnumerator implements IEnumerator<TItem>),
-			 * then the object is considered as the collection of TItem.
-			 * When the object is considered as the collection of TItem, TItem is KeyValuePair<TKey,TValue>, 
-			 * and the object implements IDictionary<TKey,TValue>, then the object is considered as dictionary of TKey and TValue.
-			 * Else, if the object has single public method IEnumerator GetEnumerator(), then the object is considered as the collection of Object.
-			 * When it also implements IDictionary, however, it is considered dictionary of Object and Object.
-			 * Otherwise, that means it implements multiple collection interface, is following.
-			 * First, if the object implements IDictionary<MessagePackObject,MessagePackObject>, then it is considered as MPO dictionary.
-			 * Second, if the object implements IEnumerable<MPO>, then it is considered as MPO dictionary.
-			 * Third, if the object implement SINGLE IDictionary<TKey,TValue> and multiple IEnumerable<T>, then it is considered as dictionary of TKey and TValue.
-			 * Fourth, the object is considered as UNSERIALIZABLE member. This behavior similer to DataContract serialization behavor
-			 * (see http://msdn.microsoft.com/en-us/library/aa347850.aspx ).
+			 * 1. If the object has single public method TEnumerator GetEnumerator() (where TEnumerator implements IEnumerator<TItem>),
+			 *    then the object is considered as the collection of TItem.
+			 *   1-1. If the object is considered as the collection of TItem, TItem is KeyValuePair<TKey,TValue>, 
+			 *        and the object implements IDictionary<TKey,TValue>,
+			 *        then the object is considered as dictionary of TKey and TValue.
+			 *   1-2. Else, if the object has single public method IEnumerator GetEnumerator(),
+			 *        then the object is considered as the collection of Object.
+			 *     1-2-1. If it also implements IDictionary,
+			 *            then it is considered dictionary of Object and Object.
+			 *     1-2-2. Otherwise, that means it implements multiple collection interface.
+			 *       1-2-2-1. First, if the object implements IDictionary<MessagePackObject,MessagePackObject>, then it is considered as MPO dictionary.
+			 *       1-2-2-2. Second, if the object implements IEnumerable<MPO>, then it is considered as MPO collection.
+			 *       1-2-2-3. Third, if the object implement SINGLE IDictionary<TKey,TValue> and multiple IEnumerable<T>, then it is considered as dictionary of TKey and TValue.
+			 *       1-2-2-4. Fourth, the object is considered as UNSERIALIZABLE member. This behavior similer to DataContract serialization behavor
+			 *                (see http://msdn.microsoft.com/en-us/library/aa347850.aspx ).
 			 */
 
-			if ( !source.IsAssignableTo( typeof( IEnumerable ) ) )
+			if (!source.IsAssignableTo(typeof(IEnumerable)))
 			{
 				return CollectionTraits.NotCollection;
 			}
 
-			if ( source.IsArray )
+			if (source.IsArray)
 			{
 				return
 					new CollectionTraits(
 						CollectionDetailedKind.Array,
+						constructorWithCapacity: null, // Never used for array.
+						defaultConstructor: null, // Never used for array.
 						source.GetElementType(),
-						null, // Never used for array.
-						null, // Never used for array.
-						null  // Never used for array.
+						getEnumeratorMethod: null, // Never used for array.
+						addMethod: null, // Never used for array.
+						countPropertyGetter: null  // Never used for array.
 					);
 			}
 
 			// If the type is an interface then a concrete collection has to be
 			// made for it (if the interface is a collection type), therefore,
 			// ignore the check for an add method
-			if ( !source.GetIsInterface() && allowNonCollectionEnumerableTypes )
+			if (!source.GetIsInterface() && allowNonCollectionEnumerableTypes)
 			{
 				options = options | CollectionTraitOptions.AllowNonCollectionEnumerableTypes;
 			}
 
-			MethodInfo getEnumerator = source.GetMethod( "GetEnumerator", ReflectionAbstractions.EmptyTypes );
-			if ( getEnumerator != null && getEnumerator.ReturnType.IsAssignableTo( typeof( IEnumerator ) ) )
+			var getEnumerator = source.GetMethod("GetEnumerator", ReflectionAbstractions.EmptyTypes);
+			if (getEnumerator != null && getEnumerator.ReturnType.IsAssignableTo(typeof(IEnumerator)))
 			{
 				// If public 'GetEnumerator' is found, it is primary collection traits.
 				CollectionTraits result;
-				if ( TryCreateCollectionTraitsForHasGetEnumeratorType( source, options, getEnumerator, out result ) )
+				if (TryCreateCollectionTraitsForHasGetEnumeratorType(source, options, getEnumerator, out result))
 				{
 					return result;
 				}
 			}
 
-			GenericCollectionTypes genericTypes = new GenericCollectionTypes();
-			Type ienumerable = null;
-			Type icollection = null;
-			Type ilist = null;
-			Type idictionary = null;
+			var genericTypes = new GenericCollectionTypes();
+			Type? ienumerable = null;
+			Type? icollection = null;
+			Type? ilist = null;
+			Type? idictionary = null;
 
-			var sourceInterfaces = source.FindInterfaces( FilterCollectionType, null );
-			if ( source.GetIsInterface() && FilterCollectionType( source, null ) )
+			var sourceInterfaces = source.FindInterfaces(FilterCollectionType, null);
+			if (source.GetIsInterface() && FilterCollectionType(source, null))
 			{
 				var originalSourceInterfaces = sourceInterfaces.ToArray();
-				var concatenatedSourceInterface = new Type[ originalSourceInterfaces.Length + 1 ];
-				concatenatedSourceInterface[ 0 ] = source;
-				for ( int i = 0; i < originalSourceInterfaces.Length; i++ )
+				var concatenatedSourceInterface = new Type[originalSourceInterfaces.Length + 1];
+				concatenatedSourceInterface[0] = source;
+				for (int i = 0; i < originalSourceInterfaces.Length; i++)
 				{
-					concatenatedSourceInterface[ i + 1 ] = originalSourceInterfaces[ i ];
+					concatenatedSourceInterface[i + 1] = originalSourceInterfaces[i];
 				}
 
 				sourceInterfaces = concatenatedSourceInterface;
 			}
 
-			foreach ( var type in sourceInterfaces )
+			foreach (var type in sourceInterfaces)
 			{
-				CollectionTraits result;
-				if ( TryCreateGenericCollectionTraits( source, type, options, out result ) )
-				{
-					return result;
-				}
-
-				if ( !DetermineCollectionInterfaces(
+				if (!DetermineCollectionInterfaces(
 						type,
 						ref genericTypes,
 						ref idictionary,
@@ -141,74 +125,88 @@ ref ienumerable
 				}
 			}
 
-			if ( genericTypes.IDictionaryT != null )
+			if (genericTypes.IDictionaryT != null)
 			{
 				var genericArguments = genericTypes.IDictionaryT.GetGenericArguments();
-				var elementType = typeof( KeyValuePair<,> ).MakeGenericType( genericArguments );
+				var elementType = typeof(KeyValuePair<,>).MakeGenericType(genericArguments);
+				var constructor = GetGenericDictionaryConstructor(source, genericArguments[0], genericArguments[1], options);
 
-				return 
+				return
 					new CollectionTraits(
 						CollectionDetailedKind.GenericDictionary,
+						constructor.WithCapacity,
+						constructor.Default,
 						elementType,
-						GetGetEnumeratorMethodFromElementType( source, elementType, options ),
-						GetAddMethod( source, genericArguments[ 0 ], genericArguments[ 1 ], options ),
-						GetCountGetterMethod( source, elementType, options )
+						GetGetEnumeratorMethodFromElementType(source, elementType, options),
+						GetAddMethod(source, genericArguments[0], genericArguments[1], options),
+						GetCountGetterMethod(source, elementType, options)
 					);
 			}
 
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-			if ( genericTypes.IReadOnlyDictionaryT != null )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+			if (genericTypes.IReadOnlyDictionaryT != null)
 			{
-				var elementType = typeof( KeyValuePair<,> ).MakeGenericType( genericTypes.IReadOnlyDictionaryT.GetGenericArguments() );
+				var genericArguments = genericTypes.IReadOnlyDictionaryT.GetGenericArguments();
+				var elementType = typeof(KeyValuePair<,>).MakeGenericType(genericArguments);
+				var constructor = GetGenericDictionaryConstructor(source, genericArguments[0], genericArguments[1], options);
+
 				return
 					new CollectionTraits(
 						CollectionDetailedKind.GenericReadOnlyDictionary,
+						constructor.WithCapacity,
+						constructor.Default,
 						elementType,
-						GetGetEnumeratorMethodFromElementType( source, elementType, options ),
-						null, // add
-						GetCountGetterMethod( source, elementType, options )
+						GetGetEnumeratorMethodFromElementType(source, elementType, options),
+						addMethod: null, // add
+						GetCountGetterMethod(source, elementType, options)
 					);
 			}
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
 
-			if ( genericTypes.IEnumerableT != null )
+			if (genericTypes.IEnumerableT != null)
 			{
 				CollectionTraits traits;
-				if ( TryCreateCollectionTraitsForIEnumerableT( source, genericTypes, options, null, out traits ) )
+				if (TryCreateCollectionTraitsForIEnumerableT(source, genericTypes, options, null, out traits))
 				{
 					return traits;
 				}
 			}
 
-			if ( idictionary != null )
+			if (idictionary != null)
 			{
+				var constructor = GetNonGenericDictionaryConstructor(source, options);
 				return
 					new CollectionTraits(
 						CollectionDetailedKind.NonGenericDictionary,
-						typeof( object ),
-						GetGetEnumeratorMethodFromEnumerableType( source, idictionary, options ),
-						GetAddMethod( source, typeof( object ), typeof( object ), options ),
-						GetCountGetterMethod( source, typeof( object ), options )
+						constructor.WithCapacity,
+						constructor.Default,
+						typeof(object),
+						GetGetEnumeratorMethodFromEnumerableType(source, idictionary, options),
+						GetAddMethod(source, typeof(object), typeof(object), options),
+						GetCountGetterMethod(source, typeof(object), options)
 					);
 			}
 
-			if ( ienumerable != null )
+			if (ienumerable != null)
 			{
-				var addMethod = GetAddMethod( source, typeof( object ), options | CollectionTraitOptions.WithAddMethod );
-				if ( addMethod != null || ( ( options & CollectionTraitOptions.AllowNonCollectionEnumerableTypes ) == 0 ) )
+				var addMethod = GetAddMethod(source, typeof(object), options | CollectionTraitOptions.WithAddMethod);
+				if (addMethod != null || ((options & CollectionTraitOptions.AllowNonCollectionEnumerableTypes) == 0))
 				{
+					var constructor = GetNonGenericCollectionConstructor(source, options);
 					// This should be appendable or unappendable collection
 					return
 						new CollectionTraits(
-							( ilist != null )
+							(ilist != null)
 								? CollectionDetailedKind.NonGenericList
-								: ( icollection != null )
+								: (icollection != null)
 									? CollectionDetailedKind.NonGenericCollection
 									: CollectionDetailedKind.NonGenericEnumerable,
-							typeof( object ),
-							GetGetEnumeratorMethodFromEnumerableType( source, ienumerable, options ),
+							constructor.WithCapacity,
+							constructor.Default,
+							typeof(object),
+							GetGetEnumeratorMethodFromEnumerableType(source, ienumerable, options),
 							addMethod,
-							GetCountGetterMethod( source, typeof( object ), options )
+							GetCountGetterMethod(source, typeof(object), options)
 						);
 				}
 			}
@@ -220,52 +218,58 @@ private static bool TryCreateCollectionTraitsForIEnumerableT(
 			Type source,
 			GenericCollectionTypes genericTypes,
 			CollectionTraitOptions options,
-			MethodInfo getMethod,
+			MethodInfo? getMethod,
 			out CollectionTraits result
 		)
 		{
-			var elementType = genericTypes.IEnumerableT.GetGenericArguments()[ 0 ];
-			var addMethod = GetAddMethod( source, elementType, options );
-			if ( addMethod == null && ( ( options & CollectionTraitOptions.AllowNonCollectionEnumerableTypes ) != 0 ) )
+			var elementType = genericTypes.IEnumerableT.GetGenericArguments()[0];
+			var addMethod = GetAddMethod(source, elementType, options);
+			if (addMethod == null && ((options & CollectionTraitOptions.AllowNonCollectionEnumerableTypes) != 0))
 			{
-				// This should be non collection object isntead of "unappendable" collection.
-				result = default( CollectionTraits );
+				// This should be non collection object instead of "unappendable" collection.
+				result = default(CollectionTraits);
 				return false;
 			}
 
 			CollectionDetailedKind kind = CollectionDetailedKind.GenericEnumerable;
-			if ( genericTypes.IListT != null )
+			if (genericTypes.IListT != null)
 			{
 				kind = CollectionDetailedKind.GenericList;
 			}
 #if !NET35 && !UNITY
-			else if ( genericTypes.ISetT != null )
+			else if (genericTypes.ISetT != null)
 			{
 				kind = CollectionDetailedKind.GenericSet;
 			}
 #endif // !NET35 && !UNITY
-			else if ( genericTypes.ICollectionT != null )
+			else if (genericTypes.ICollectionT != null)
 			{
 				kind = CollectionDetailedKind.GenericCollection;
 			}
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-			else if ( genericTypes.IReadOnlyListT != null )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+			else if (genericTypes.IReadOnlyListT != null)
 			{
 				kind = CollectionDetailedKind.GenericReadOnlyList;
 			}
-			else if ( genericTypes.IReadOnlyCollectionT != null )
+			else if (genericTypes.IReadOnlyCollectionT != null)
 			{
 				kind = CollectionDetailedKind.GenericReadOnlyCollection;
 			}
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				
+
+			var constructor =
+				kind == CollectionDetailedKind.GenericSet ?
+					GetGenericSetConstructor(source, elementType, options) :
+					GetGenericCollectionConstructor(source, elementType, options);
 			result =
 				new CollectionTraits(
 					kind,
+					constructor.WithCapacity,
+					constructor.Default,
 					elementType,
-					getMethod ?? GetGetEnumeratorMethodFromElementType( source, elementType, options ),
+					getMethod ?? GetGetEnumeratorMethodFromElementType(source, elementType, options),
 					addMethod,
-					GetCountGetterMethod( source, elementType, options )
+					GetCountGetterMethod(source, elementType, options)
 				);
 			return true;
 		}
@@ -277,50 +281,56 @@ private static bool TryCreateCollectionTraitsForHasGetEnumeratorType(
 			out CollectionTraits result
 		)
 		{
-			if ( source.Implements( typeof( IDictionary<,> ) )
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				|| source.Implements( typeof( IReadOnlyDictionary<,> ) )
+			if (source.Implements(typeof(IDictionary<,>))
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+				|| source.Implements(typeof(IReadOnlyDictionary<,>))
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
 			)
 			{
 				var ienumetaorT =
 					getEnumerator.ReturnType.GetInterfaces()
-						.FirstOrDefault( @interface => 
-												@interface.GetIsGenericType() && @interface.GetGenericTypeDefinition() == typeof( IEnumerator<> ) 
+						.FirstOrDefault(@interface =>
+							@interface.GetIsGenericType() && @interface.GetGenericTypeDefinition() == typeof(IEnumerator<>)
 						);
-				if ( ienumetaorT != null )
+				if (ienumetaorT != null)
 				{
-					var elementType = ienumetaorT.GetGenericArguments()[ 0 ];
+					var elementType = ienumetaorT.GetGenericArguments()[0];
 					var elementTypeGenericArguments = elementType.GetGenericArguments();
+					var constructor = GetGenericDictionaryConstructor(source, elementTypeGenericArguments[0], elementTypeGenericArguments[1], options);
 
-					result = 
+					result =
 						new CollectionTraits(
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-							source.Implements( typeof( IDictionary<,> ) )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+							source.Implements(typeof(IDictionary<,>))
 								? CollectionDetailedKind.GenericDictionary
 								: CollectionDetailedKind.GenericReadOnlyDictionary,
 #else
 							CollectionDetailedKind.GenericDictionary,
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+							constructor.WithCapacity,
+							constructor.Default,
 							elementType,
 							getEnumerator,
-							GetAddMethod( source, elementTypeGenericArguments[ 0 ], elementTypeGenericArguments [ 1 ], options ),
-							GetCountGetterMethod( source, elementType, options )
+							GetAddMethod(source, elementTypeGenericArguments[0], elementTypeGenericArguments[1], options),
+							GetCountGetterMethod(source, elementType, options)
 						);
 
 					return true;
 				}
 			}
 
-			if ( source.IsAssignableTo( typeof( IDictionary ) ) )
+			if (source.IsAssignableTo(typeof(IDictionary)))
 			{
-				result = 
+				var constructor = GetNonGenericDictionaryConstructor(source, options);
+				result =
 					new CollectionTraits(
 						CollectionDetailedKind.NonGenericDictionary,
-						typeof( DictionaryEntry ),
+						constructor.WithCapacity,
+						constructor.Default,
+						typeof(DictionaryEntry),
 						getEnumerator,
-						GetAddMethod( source, typeof( object ), typeof( object ), options ),
-						GetCountGetterMethod( source, typeof( object ), options )
+						GetAddMethod(source, typeof(object), typeof(object), options),
+						GetCountGetterMethod(source, typeof(object), options)
 					);
 
 				return true;
@@ -329,154 +339,90 @@ out CollectionTraits result
 			// Block to limit variable scope
 			{
 				var ienumetaorT =
-					IsIEnumeratorT( getEnumerator.ReturnType )
+					IsIEnumeratorT(getEnumerator.ReturnType)
 						? getEnumerator.ReturnType
-						: getEnumerator.ReturnType.GetInterfaces().FirstOrDefault( IsIEnumeratorT );
+						: getEnumerator.ReturnType.GetInterfaces().FirstOrDefault(IsIEnumeratorT);
 
-				if ( ienumetaorT != null )
+				if (ienumetaorT != null)
 				{
 					// Get the open generic types once
 					Type[] genericInterfaces =
 						source.GetInterfaces()
-							.Where( i => i.GetIsGenericType() )
-							.Select( i => i.GetGenericTypeDefinition() )
+							.Where(i => i.GetIsGenericType())
+							.Select(i => i.GetGenericTypeDefinition())
 							.ToArray();
 
 					var genericTypes = new GenericCollectionTypes();
 					genericTypes.IEnumerableT = ienumetaorT;
-					genericTypes.ICollectionT = genericInterfaces.FirstOrDefault( i => i == typeof(ICollection<>) );
-					genericTypes.IListT = genericInterfaces.FirstOrDefault( i => i == typeof(IList<>) );
+					genericTypes.ICollectionT = genericInterfaces.FirstOrDefault(i => i == typeof(ICollection<>));
+					genericTypes.IListT = genericInterfaces.FirstOrDefault(i => i == typeof(IList<>));
 
 #if !NET35 && !UNITY
-					genericTypes.ISetT = genericInterfaces.FirstOrDefault( i => i == typeof(ISet<>) );
+					genericTypes.ISetT = genericInterfaces.FirstOrDefault(i => i == typeof(ISet<>));
 #endif // !NET35 && !UNITY
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-					genericTypes.IReadOnlyCollectionT = genericInterfaces.FirstOrDefault( i => i == typeof(IReadOnlyCollection<>) );
-					genericTypes.IReadOnlyListT = genericInterfaces.FirstOrDefault( i => i == typeof(IReadOnlyList<>) );
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+					genericTypes.IReadOnlyCollectionT = genericInterfaces.FirstOrDefault(i => i == typeof(IReadOnlyCollection<>));
+					genericTypes.IReadOnlyListT = genericInterfaces.FirstOrDefault(i => i == typeof(IReadOnlyList<>));
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
 
-					return TryCreateCollectionTraitsForIEnumerableT( source, genericTypes, options, getEnumerator, out result );
+					return TryCreateCollectionTraitsForIEnumerableT(source, genericTypes, options, getEnumerator, out result);
 				}
 			}
 
-			result = default( CollectionTraits );
-			return false;
-		}
-
-
-		private static bool TryCreateGenericCollectionTraits( Type source, Type type, CollectionTraitOptions options, out CollectionTraits result )
-		{
-			if ( type == typeof( IDictionary<MessagePackObject, MessagePackObject> )
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				|| type == typeof( IReadOnlyDictionary<MessagePackObject, MessagePackObject> )
-#endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-			)
-			{
-				result = 
-					new CollectionTraits(
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-						( source == typeof( IDictionary<MessagePackObject, MessagePackObject> ) || source.Implements( typeof( IDictionary<MessagePackObject, MessagePackObject> ) ) )
-							? CollectionDetailedKind.GenericDictionary
-							: CollectionDetailedKind.GenericReadOnlyDictionary,
-#else
-						CollectionDetailedKind.GenericDictionary,
-#endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-						typeof( KeyValuePair<MessagePackObject, MessagePackObject> ),
-						GetGetEnumeratorMethodFromEnumerableType( source, typeof( IEnumerable<KeyValuePair<MessagePackObject, MessagePackObject>> ), options ),
-						GetAddMethod( source, typeof( MessagePackObject ), typeof( MessagePackObject ), options ),
-						GetCountGetterMethod( source, typeof( KeyValuePair<MessagePackObject, MessagePackObject> ), options )
-					);
-
-				return true;
-			}
-
-			if ( type == typeof( IEnumerable<MessagePackObject> ) )
-			{
-				var addMethod = GetAddMethod( source, typeof( MessagePackObject ), options | CollectionTraitOptions.WithAddMethod );
-				if ( addMethod != null )
-				{
-					{
-						result = 
-							new CollectionTraits(
-								( source == typeof( IList<MessagePackObject> ) || source.Implements( typeof( IList<MessagePackObject> ) ) )
-									? CollectionDetailedKind.GenericList
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-									: ( source == typeof( IReadOnlyList<MessagePackObject> ) || source.Implements( typeof( IReadOnlyList<MessagePackObject> ) ) )
-										? CollectionDetailedKind.GenericReadOnlyList
-#endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-#if !NET35 && !UNITY
-										: ( source == typeof( ISet<MessagePackObject> ) || source.Implements( typeof( ISet<MessagePackObject> ) ) )
-											? CollectionDetailedKind.GenericSet
-#endif // !NET35 && !UNITY
-											: ( source == typeof( ICollection<MessagePackObject> ) ||
-												source.Implements( typeof( ICollection<MessagePackObject> ) ) )
-												? CollectionDetailedKind.GenericCollection
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-												: ( source == typeof( IReadOnlyCollection<MessagePackObject> ) || source.Implements( typeof( IReadOnlyCollection<MessagePackObject> ) ) )
-													? CollectionDetailedKind.GenericReadOnlyCollection
-#endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-													: CollectionDetailedKind.GenericEnumerable,
-								typeof( MessagePackObject ),
-								GetGetEnumeratorMethodFromEnumerableType( source, typeof( IEnumerable<MessagePackObject> ), options ),
-								addMethod,
-								GetCountGetterMethod( source, typeof( MessagePackObject ), options )
-							);
-
-						return true;
-					}
-				}
-			}
-
-			result = default( CollectionTraits );
+			result = default(CollectionTraits);
 			return false;
 		}
 
 		private static bool DetermineCollectionInterfaces(
 			Type type,
 			ref GenericCollectionTypes genericTypes,
-			ref Type idictionary,
-			ref Type ilist,
-			ref Type icollection,
-			ref Type ienumerable
+			ref Type? idictionary,
+			ref Type? ilist,
+			ref Type? icollection,
+			ref Type? ienumerable
 		)
 		{
-			if ( type.GetIsGenericType() )
+			if (type.GetIsGenericType())
 			{
 				var genericTypeDefinition = type.GetGenericTypeDefinition();
-				if ( genericTypeDefinition == typeof( IDictionary<,> ) )
+				if (genericTypeDefinition == typeof(IDictionary<,>))
 				{
-					if ( genericTypes.IDictionaryT != null )
+					if (genericTypes.IDictionaryT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
 					genericTypes.IDictionaryT = type;
 				}
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				else if ( genericTypeDefinition == typeof( IReadOnlyDictionary<,> ) )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+				else if (genericTypeDefinition == typeof(IReadOnlyDictionary<,>))
 				{
-					if ( genericTypes.IReadOnlyDictionaryT != null )
+					if (genericTypes.IReadOnlyDictionaryT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
 					genericTypes.IReadOnlyDictionaryT = type;
 				}
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				else if ( genericTypeDefinition == typeof( IList<> ) )
+				else if (genericTypeDefinition == typeof(IList<>))
 				{
-					if ( genericTypes.IListT != null )
+					if (genericTypes.IListT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
 					genericTypes.IListT = type;
 				}
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				else if ( genericTypeDefinition == typeof( IReadOnlyList<> ) )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+				else if (genericTypeDefinition == typeof(IReadOnlyList<>))
 				{
-					if ( genericTypes.IReadOnlyListT != null )
+					if (genericTypes.IReadOnlyListT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
@@ -484,40 +430,44 @@ ref Type ienumerable
 				}
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
 #if !NET35 && !UNITY
-				else if ( genericTypeDefinition == typeof( ISet<> ) )
+				else if (genericTypeDefinition == typeof(ISet<>))
 				{
-					if ( genericTypes.ISetT != null )
+					if (genericTypes.ISetT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
 					genericTypes.ISetT = type;
 				}
 #endif // !NET35 && !UNITY
-				else if ( genericTypeDefinition == typeof( ICollection<> ) )
+				else if (genericTypeDefinition == typeof(ICollection<>))
 				{
-					if ( genericTypes.ICollectionT != null )
+					if (genericTypes.ICollectionT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
 					genericTypes.ICollectionT = type;
 				}
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				else if ( genericTypeDefinition == typeof( IReadOnlyCollection<> ) )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
+				else if (genericTypeDefinition == typeof(IReadOnlyCollection<>))
 				{
-					if ( genericTypes.IReadOnlyCollectionT != null )
+					if (genericTypes.IReadOnlyCollectionT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
 					genericTypes.IReadOnlyCollectionT = type;
 				}
 #endif // !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
-				else if ( genericTypeDefinition == typeof( IEnumerable<> ) )
+				else if (genericTypeDefinition == typeof(IEnumerable<>))
 				{
-					if ( genericTypes.IEnumerableT != null )
+					if (genericTypes.IEnumerableT != null)
 					{
+						// multiple candidates
 						return false;
 					}
 
@@ -526,19 +476,19 @@ ref Type ienumerable
 			}
 			else
 			{
-				if ( type == typeof( IDictionary ) )
+				if (type == typeof(IDictionary))
 				{
 					idictionary = type;
 				}
-				else if ( type == typeof( IList ) )
+				else if (type == typeof(IList))
 				{
 					ilist = type;
 				}
-				else if ( type == typeof( ICollection ) )
+				else if (type == typeof(ICollection))
 				{
 					icollection = type;
 				}
-				else if ( type == typeof( IEnumerable ) )
+				else if (type == typeof(IEnumerable))
 				{
 					ienumerable = type;
 				}
@@ -547,46 +497,46 @@ ref Type ienumerable
 			return true;
 		}
 
-		private static MethodInfo GetGetEnumeratorMethodFromElementType( Type targetType, Type elementType, CollectionTraitOptions options )
+		private static MethodInfo? GetGetEnumeratorMethodFromElementType(Type targetType, Type elementType, CollectionTraitOptions options)
 		{
-			if ( ( options | CollectionTraitOptions.WithGetEnumeratorMethod ) == 0 )
+			if ((options | CollectionTraitOptions.WithGetEnumeratorMethod) == 0)
 			{
 				return null;
 			}
 
-			return FindInterfaceMethod( targetType, typeof( IEnumerable<> ).MakeGenericType( elementType ), "GetEnumerator", ReflectionAbstractions.EmptyTypes );
+			return FindInterfaceMethod(targetType, typeof(IEnumerable<>).MakeGenericType(elementType), "GetEnumerator", ReflectionAbstractions.EmptyTypes);
 		}
 
-		private static MethodInfo GetGetEnumeratorMethodFromEnumerableType( Type targetType, Type enumerableType, CollectionTraitOptions options )
+		private static MethodInfo? GetGetEnumeratorMethodFromEnumerableType(Type targetType, Type enumerableType, CollectionTraitOptions options)
 		{
-			if ( ( options | CollectionTraitOptions.WithGetEnumeratorMethod ) == 0 )
+			if ((options | CollectionTraitOptions.WithGetEnumeratorMethod) == 0)
 			{
 				return null;
 			}
 
-			return FindInterfaceMethod( targetType, enumerableType, "GetEnumerator", ReflectionAbstractions.EmptyTypes );
+			return FindInterfaceMethod(targetType, enumerableType, "GetEnumerator", ReflectionAbstractions.EmptyTypes);
 		}
 
-		private static MethodInfo FindInterfaceMethod( Type targetType, Type interfaceType, string name, Type[] parameterTypes )
+		private static MethodInfo? FindInterfaceMethod(Type targetType, Type interfaceType, string name, Type[] parameterTypes)
 		{
-			if ( targetType.GetIsInterface() )
+			if (targetType.GetIsInterface())
 			{
-				return targetType.FindInterfaces( ( type, _ ) => type == interfaceType, null ).Single().GetMethod( name, parameterTypes );
+				return targetType.FindInterfaces((type, _) => type == interfaceType, null).Single().GetMethod(name, parameterTypes);
 			}
 
-			var map = targetType.GetInterfaceMap( interfaceType );
+			var map = targetType.GetInterfaceMap(interfaceType);
 
 #if !SILVERLIGHT || WINDOWS_PHONE
-			int index = Array.FindIndex( map.InterfaceMethods, method => method.Name == name && method.GetParameters().Select( p => p.ParameterType ).SequenceEqual( parameterTypes ) );
+			int index = Array.FindIndex(map.InterfaceMethods, method => method.Name == name && method.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameterTypes));
 #else
 			int index = map.InterfaceMethods.FindIndex( method => method.Name == name && method.GetParameters().Select( p => p.ParameterType ).SequenceEqual( parameterTypes ) );
 #endif
 
-			if ( index < 0 )
+			if (index < 0)
 			{
 #if DEBUG
 #if !NET35 && !UNITY
-				Contract.Assert( false, interfaceType + "::" + name + "(" + String.Join<Type>( ", ", parameterTypes ) + ") is not found in " + targetType );
+				Contract.Assert(false, interfaceType + "::" + name + "(" + String.Join<Type>(", ", parameterTypes) + ") is not found in " + targetType);
 #else
 				Contract.Assert( false, interfaceType + "::" + name + "(" + String.Join( ", ", parameterTypes.Select( t => t.ToString() ).ToArray() ) + ") is not found in " + targetType );
 #endif // !NET35
@@ -595,50 +545,50 @@ private static MethodInfo FindInterfaceMethod( Type targetType, Type interfaceTy
 				return null;
 			}
 
-			return map.TargetMethods[ index ];
+			return map.TargetMethods[index];
 		}
 
-		private static MethodInfo GetAddMethod( Type targetType, Type argumentType, CollectionTraitOptions options )
+		private static MethodInfo? GetAddMethod(Type targetType, Type argumentType, CollectionTraitOptions options)
 		{
-			if ( ( options | CollectionTraitOptions.WithAddMethod ) == 0 )
+			if ((options | CollectionTraitOptions.WithAddMethod) == 0)
 			{
 				return null;
 			}
 
 			var argumentTypes = new[] { argumentType };
-			var typedAdd = targetType.GetMethod( "Add", argumentTypes );
-			if ( typedAdd != null )
+			var typedAdd = targetType.GetMethod("Add", argumentTypes);
+			if (typedAdd != null)
 			{
 				return typedAdd;
 			}
 
-			var icollectionT = typeof( ICollection<> ).MakeGenericType( argumentType );
-			if ( targetType.IsAssignableTo( icollectionT ) )
+			var icollectionT = typeof(ICollection<>).MakeGenericType(argumentType);
+			if (targetType.IsAssignableTo(icollectionT))
 			{
-				return icollectionT.GetMethod( "Add", argumentTypes );
+				return icollectionT.GetMethod("Add", argumentTypes);
 			}
 
 			// It ensures .NET Framework and .NET Core compatibility and provides "natural" feel.
-			var objectAdd = targetType.GetMethod( "Add", ObjectAddParameterTypes );
-			if ( objectAdd != null )
+			var objectAdd = targetType.GetMethod("Add", ObjectAddParameterTypes);
+			if (objectAdd != null)
 			{
 				return objectAdd;
 			}
 
-			if ( targetType.IsAssignableTo( typeof( IList ) ) )
+			if (targetType.IsAssignableTo(typeof(IList)))
 			{
-				return typeof( IList ).GetMethod( "Add", ObjectAddParameterTypes );
+				return typeof(IList).GetMethod("Add", ObjectAddParameterTypes);
 			}
 
 			return null;
 		}
 
 		// ReSharper disable UnusedParameter.Local
-		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "targetType", Justification = "For Unity compatibility" )]
-		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "elementType", Justification = "For Unity compatibility" )]
-		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "options", Justification = "For Unity compatibility" )]
-		private static MethodInfo GetCountGetterMethod( Type targetType, Type elementType, CollectionTraitOptions options )
-			// ReSharper restore UnusedParameter.Local
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "targetType", Justification = "For Unity compatibility")]
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "elementType", Justification = "For Unity compatibility")]
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "options", Justification = "For Unity compatibility")]
+		private static MethodInfo? GetCountGetterMethod(Type targetType, Type elementType, CollectionTraitOptions options)
+		// ReSharper restore UnusedParameter.Local
 		{
 #if !UNITY
 			// get_Count is not used other than Unity.
@@ -661,7 +611,7 @@ private static MethodInfo GetCountGetterMethod( Type targetType, Type elementTyp
 				return icollectionT.GetProperty( "Count" ).GetGetMethod();
 			}
 
-#if !NET35 && !UNITY && !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+#if !NET35 && !UNITY && !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
 			var ireadOnlyCollectionT = typeof( IReadOnlyCollection<> ).MakeGenericType( elementType );
 			if ( targetType.IsAssignableTo( ireadOnlyCollectionT ) )
 			{
@@ -678,30 +628,30 @@ private static MethodInfo GetCountGetterMethod( Type targetType, Type elementTyp
 #endif // !UNITY
 		}
 
-		private static MethodInfo GetAddMethod( Type targetType, Type keyType, Type valueType, CollectionTraitOptions options )
+		private static MethodInfo? GetAddMethod(Type targetType, Type keyType, Type valueType, CollectionTraitOptions options)
 		{
-			if ( ( options | CollectionTraitOptions.WithAddMethod ) == 0 )
+			if ((options | CollectionTraitOptions.WithAddMethod) == 0)
 			{
 				return null;
 			}
 
 			var argumentTypes = new[] { keyType, valueType };
-			var result = targetType.GetMethod( "Add", argumentTypes );
-			if ( result != null )
+			var result = targetType.GetMethod("Add", argumentTypes);
+			if (result != null)
 			{
 				return result;
 			}
 
-			return typeof( IDictionary<,> ).MakeGenericType( argumentTypes ).GetMethod( "Add", argumentTypes );
+			return typeof(IDictionary<,>).MakeGenericType(argumentTypes).GetMethod("Add", argumentTypes);
 		}
 
-		private static bool FilterCollectionType( Type type, object filterCriteria )
+		private static bool FilterCollectionType(Type type, object? filterCriteria)
 		{
 #if !NETSTANDARD1_1 && !NETSTANDARD1_3
 #if DEBUG
-			Contract.Assert( type.GetIsInterface(), "type.IsInterface" );
+			Contract.Assert(type.GetIsInterface(), "type.IsInterface");
 #endif // DEBUG
-			return type.GetAssembly().Equals( typeof( Array ).GetAssembly() ) && ( type.Namespace == "System.Collections" || type.Namespace == "System.Collections.Generic" );
+			return type.GetAssembly().Equals(typeof(Array).GetAssembly()) && (type.Namespace == "System.Collections" || type.Namespace == "System.Collections.Generic");
 #else
 			var typeInfo = type.GetTypeInfo();
 			Contract.Assert( typeInfo.IsInterface );
@@ -709,9 +659,9 @@ private static bool FilterCollectionType( Type type, object filterCriteria )
 #endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
 		}
 
-		private static bool IsIEnumeratorT( Type @interface )
+		private static bool IsIEnumeratorT(Type @interface)
 		{
-			return @interface.GetIsGenericType() && @interface.GetGenericTypeDefinition() == typeof( IEnumerator<> );
+			return @interface.GetIsGenericType() && @interface.GetGenericTypeDefinition() == typeof(IEnumerator<>);
 		}
 #if WINDOWS_PHONE
 		public static IEnumerable<Type> FindInterfaces( this Type source, Func<Type, object, bool> filter, object criterion )
@@ -726,11 +676,9 @@ public static IEnumerable<Type> FindInterfaces( this Type source, Func<Type, obj
 		}
 #endif
 
-		public static bool GetHasPublicGetter( this MemberInfo source )
+		public static bool GetHasPublicGetter(this MemberInfo source)
 		{
-			PropertyInfo asProperty;
-			FieldInfo asField;
-			if ( ( asProperty = source as PropertyInfo ) != null )
+			if (source is PropertyInfo asProperty)
 			{
 #if !NETSTANDARD1_1 && !NETSTANDARD1_3
 				return asProperty.GetGetMethod() != null;
@@ -738,21 +686,19 @@ public static bool GetHasPublicGetter( this MemberInfo source )
 				return ( asProperty.GetMethod != null && asProperty.GetMethod.IsPublic );
 #endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
 			}
-			else if ( ( asField = source as FieldInfo ) != null )
+			else if (source is FieldInfo asField)
 			{
 				return asField.IsPublic;
 			}
 			else
 			{
-				throw new NotSupportedException( source.GetType() + " is not supported." );
+				throw new NotSupportedException(source.GetType() + " is not supported.");
 			}
 		}
 
-		public static bool GetHasPublicSetter( this MemberInfo source )
+		public static bool GetHasPublicSetter(this MemberInfo source)
 		{
-			PropertyInfo asProperty;
-			FieldInfo asField;
-			if ( ( asProperty = source as PropertyInfo ) != null )
+			if (source is PropertyInfo asProperty)
 			{
 #if !NETSTANDARD1_1 && !NETSTANDARD1_3
 				return asProperty.GetSetMethod() != null;
@@ -760,51 +706,144 @@ public static bool GetHasPublicSetter( this MemberInfo source )
 				return ( asProperty.SetMethod != null && asProperty.SetMethod.IsPublic );
 #endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
 			}
-			else if ( ( asField = source as FieldInfo ) != null )
+			else if (source is FieldInfo asField)
 			{
 				return asField.IsPublic && !asField.IsInitOnly && !asField.IsLiteral;
 			}
 			else
 			{
-				throw new NotSupportedException( source.GetType() + " is not supported." );
+				throw new NotSupportedException(source.GetType() + " is not supported.");
 			}
 		}
 
-		public static bool GetIsPublic( this MemberInfo source )
+		public static bool GetIsPublic(this MemberInfo source)
 		{
-			PropertyInfo asProperty;
-			FieldInfo asField;
-			MethodBase asMethod;
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
-			Type asType;
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
-			if ( ( asProperty = source as PropertyInfo ) != null )
+			if (source is PropertyInfo asProperty)
 			{
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
-				return asProperty.GetAccessors( true ).Where( a => a.ReturnType != typeof( void ) ).All( a => a.IsPublic );
-#else
-				return
-					( asProperty.GetMethod == null || asProperty.GetMethod.IsPublic );
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
+				return asProperty.GetAccessors(true).Where(a => a.ReturnType != typeof(void)).All(a => a.IsPublic);
 			}
-			else if ( ( asField = source as FieldInfo ) != null )
+			else if (source is FieldInfo asField)
 			{
 				return asField.IsPublic;
 			}
-			else if ( ( asMethod = source as MethodBase ) != null )
+			else if (source is MethodBase asMethod)
 			{
 				return asMethod.IsPublic;
 			}
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
-			else if ( ( asType = source as Type ) != null )
+			else if (source is Type asType)
 			{
 				return asType.IsPublic;
 			}
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
 			else
 			{
-				throw new NotSupportedException( source.GetType() + " is not supported." );
+				throw new NotSupportedException(source.GetType() + " is not supported.");
+			}
+		}
+
+		private static (ConstructorInfo? WithCapacity, ConstructorInfo? Default) GetGenericCollectionConstructor(Type source, Type elementType, CollectionTraitOptions options)
+		{
+			if ((options & CollectionTraitOptions.WithConstructor) == 0)
+			{
+				// skip
+				return (null, null);
 			}
+
+			if (source.GetIsInterface())
+			{
+				var listOfT = typeof(List<>).MakeGenericType(elementType);
+				return
+					(listOfT.GetConstructor(WithCapacityConstructorParameterTypes),
+					listOfT.GetConstructor(ReflectionAbstractions.EmptyTypes));
+			}
+
+			return GetConcreteCollectionConstructor(source);
+		}
+
+		private static (ConstructorInfo? WithCapacity, ConstructorInfo? Default) GetGenericSetConstructor(Type source, Type elementType, CollectionTraitOptions options)
+		{
+			if ((options & CollectionTraitOptions.WithConstructor) == 0)
+			{
+				// skip
+				return (null, null);
+			}
+
+			if (source.GetIsInterface())
+			{
+				var hashSetOfT = typeof(HashSet<>).MakeGenericType(elementType);
+				return
+					(hashSetOfT.GetConstructor(WithCapacityConstructorParameterTypes),
+					hashSetOfT.GetConstructor(ReflectionAbstractions.EmptyTypes));
+			}
+
+			return GetConcreteCollectionConstructor(source);
+		}
+
+		private static (ConstructorInfo? WithCapacity, ConstructorInfo? Default) GetGenericDictionaryConstructor(Type source, Type keyType, Type valueType, CollectionTraitOptions options)
+		{
+			if ((options & CollectionTraitOptions.WithConstructor) == 0)
+			{
+				// skip
+				return (null, null);
+			}
+
+			if (source.GetIsInterface())
+			{
+				var dictionaryOfTkeyAndTvalue = typeof(Dictionary<,>).MakeGenericType(keyType, valueType);
+				return
+					(dictionaryOfTkeyAndTvalue.GetConstructor(WithCapacityConstructorParameterTypes),
+					dictionaryOfTkeyAndTvalue.GetConstructor(ReflectionAbstractions.EmptyTypes));
+			}
+
+			return GetConcreteCollectionConstructor(source);
+		}
+
+		private static (ConstructorInfo? WithCapacity, ConstructorInfo? Default) GetNonGenericCollectionConstructor(Type source, CollectionTraitOptions options)
+		{
+			if ((options & CollectionTraitOptions.WithConstructor) == 0)
+			{
+				// skip
+				return (null, null);
+			}
+
+			if (source.GetIsInterface())
+			{
+				return ArrayListConstructors;
+			}
+
+			return GetConcreteCollectionConstructor(source);
+		}
+
+		private static (ConstructorInfo? WithCapacity, ConstructorInfo? Default) GetNonGenericDictionaryConstructor(Type source, CollectionTraitOptions options)
+		{
+			if ((options & CollectionTraitOptions.WithConstructor) == 0)
+			{
+				// skip
+				return (null, null);
+			}
+
+			if (source.GetIsInterface())
+			{
+				return HashtableConstructors;
+			}
+
+			return GetConcreteCollectionConstructor(source);
+		}
+
+		private static (ConstructorInfo? WithCapacity, ConstructorInfo? Default) GetConcreteCollectionConstructor(Type source)
+		{
+			var @default = source.GetConstructor(ReflectionAbstractions.EmptyTypes);
+			var withCapacity = source.GetConstructor(BindingFlags.Public | BindingFlags.Instance, binder: null, WithCapacityConstructorParameterTypes, null);
+			if (withCapacity != null)
+			{
+				var shouldBeCapacity = withCapacity.GetParameters()[0].Name;
+				if (!String.Equals(shouldBeCapacity, "capacity", StringComparison.OrdinalIgnoreCase)
+					&& !String.Equals(shouldBeCapacity, "initialCapacity", StringComparison.OrdinalIgnoreCase))
+				{
+					shouldBeCapacity = null;
+				}
+			}
+
+			return (withCapacity, @default);
 		}
 
 		private struct GenericCollectionTypes
@@ -817,7 +856,7 @@ private struct GenericCollectionTypes
 
 #if !NET35 && !UNITY
 			internal Type ISetT;
-#if !NET40 && !( SILVERLIGHT && !WINDOWS_PHONE )
+#if !NET40 && !(SILVERLIGHT && !WINDOWS_PHONE)
 			internal Type IReadOnlyCollectionT;
 			internal Type IReadOnlyListT;
 			internal Type IReadOnlyDictionaryT;
diff --git a/src/MsgPack/Serialization/ReflectionExtensions.ConstructorDelegate.cs b/src/MsgPack/Serialization/ReflectionExtensions.ConstructorDelegate.cs
index edb877716..7a48f920f 100644
--- a/src/MsgPack/Serialization/ReflectionExtensions.ConstructorDelegate.cs
+++ b/src/MsgPack/Serialization/ReflectionExtensions.ConstructorDelegate.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Reflection;
@@ -26,42 +10,42 @@
 
 namespace MsgPack.Serialization
 {
-	partial class ReflectionExtensions
+	internal partial class ReflectionExtensions
 	{
-		public static TDelegate CreateConstructorDelegate<TDelegate>( this ConstructorInfo constructor )
+		public static TDelegate CreateConstructorDelegate<TDelegate>(this ConstructorInfo constructor)
 		{
-			return ( TDelegate )CreateDelegate( typeof( TDelegate ), constructor.DeclaringType, constructor, constructor.GetParameterTypes() );
+			return (TDelegate)CreateDelegate(typeof(TDelegate), constructor.DeclaringType, constructor, constructor.GetParameterTypes());
 		}
 
-		private static object CreateDelegate( Type delegateType, Type targetType, ConstructorInfo constructor, Type[] parameterTypes )
+		private static object CreateDelegate(Type delegateType, Type targetType, ConstructorInfo constructor, Type[] parameterTypes)
 		{
 			var dynamicMethod =
 #if !SILVERLIGHT
-				new DynamicMethod( "Create" + targetType.Name, targetType, parameterTypes, restrictedSkipVisibility: true );
+				new DynamicMethod("Create" + targetType.Name, targetType, parameterTypes, restrictedSkipVisibility: true);
 #else
 				new DynamicMethod( "Create" + targetType.Name, targetType, parameterTypes );
 #endif // !SILVERLIGHT
-			var il = new TracingILGenerator( dynamicMethod, NullTextWriter.Instance, isDebuggable: false );
-			if ( constructor == null )
+			var il = new TracingILGenerator(dynamicMethod, NullTextWriter.Instance, isDebuggable: false);
+			if (constructor == null)
 			{
 				// Value type's init.
-				il.DeclareLocal( targetType );
-				il.EmitAnyLdloca( 0 );
-				il.EmitInitobj( targetType );
-				il.EmitAnyLdloc( 0 );
+				il.DeclareLocal(targetType);
+				il.EmitAnyLdloca(0);
+				il.EmitInitobj(targetType);
+				il.EmitAnyLdloc(0);
 			}
 			else
 			{
-				for ( var i = 0; i < parameterTypes.Length; i++ )
+				for (var i = 0; i < parameterTypes.Length; i++)
 				{
-					il.EmitAnyLdarg( i );
+					il.EmitAnyLdarg(i);
 				}
 
-				il.EmitNewobj( constructor );
+				il.EmitNewobj(constructor);
 			}
 
 			il.EmitRet();
-			return dynamicMethod.CreateDelegate( delegateType );
+			return dynamicMethod.CreateDelegate(delegateType);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/ReflectionExtensions.cs b/src/MsgPack/Serialization/ReflectionExtensions.cs
index e195da43b..f4d671b1c 100644
--- a/src/MsgPack/Serialization/ReflectionExtensions.cs
+++ b/src/MsgPack/Serialization/ReflectionExtensions.cs
@@ -1,29 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke and contributors
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// Contributors:
-//    Samuel Cragg
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 #if FEATURE_MPCONTRACT
@@ -32,6 +9,7 @@
 using System.Diagnostics.Contracts;
 #endif // FEATURE_MPCONTRACT
 using System.Globalization;
+using System.Linq;
 using System.Reflection;
 
 namespace MsgPack.Serialization
@@ -43,31 +21,82 @@ namespace MsgPack.Serialization
 #endif
 	static partial class ReflectionExtensions
 	{
-		private static readonly Type[] ExceptionConstructorWithInnerParameterTypes = { typeof( string ), typeof( Exception ) };
-		private static readonly Type[] ObjectAddParameterTypes = { typeof( object ) };
+		private const string NullableAttributeTypeName = "System.CompilerServices.NullableAttribute";
+		private const string NullableContextAttributeTypeName = "System.CompilerServices.NullableContextAttribute";
+
+		private static readonly Type[] ExceptionConstructorWithInnerParameterTypes = { typeof(string), typeof(Exception) };
+		private static readonly Type[] ObjectAddParameterTypes = { typeof(object) };
+
+		public static bool IsNullableType(this Type type)
+			=> !type.GetIsValueType() || Nullable.GetUnderlyingType(type) != null;
+
+		public static bool IsNullable(this MemberInfo member)
+		{
+			// see https://github.com/dotnet/roslyn/blob/master/docs/features/nullable-metadata.md
+			var nullabileArguments = member.GetCustomAttributesData().SingleOrDefault(a => a.AttributeType.FullName == NullableAttributeTypeName)?.GetConstructorArguments();
+			if (nullabileArguments?[0].ArgumentType == typeof(byte))
+			{
+				var nullability = (byte)nullabileArguments[0].Value!;
+				if (nullability!=0)
+				{
+					return nullability == 2;
+				}
+			}
+			else if (nullabileArguments?[0].ArgumentType == typeof(byte[]))
+			{
+				var nullability = ((byte[])nullabileArguments[0].Value!)[0];
+				if (nullability != 0)
+				{
+					return nullability == 2;
+				}
+			}
+
+			// Note: oblivious (0) will be treated as nullable in this context.
+			return 
+				(byte)member.DeclaringType!
+					.GetCustomAttributesData()
+					.SingleOrDefault(a => a.AttributeType.FullName == NullableContextAttributeTypeName)?
+					.GetConstructorArguments()[0].Value!
+				!= 1;
+		}
+
+		public static bool IsCodecPrimitive(this Type type)
+			=> type.GetIsPrimitive()
+				&& (Type.GetTypeCode(type) switch
+				{
+					TypeCode.Char | TypeCode.Object => false,
+					_ => true
+				});
+
+		public static bool IsAssignableTo(this Type type, Type t)
+			=> t.IsAssignableFrom(type);
+
+		public static TDelegate CreateDelegate<TDelegate>(this MethodInfo method)
+			where TDelegate : Delegate
+			=> (TDelegate)method.CreateDelegate(typeof(TDelegate));
 
-		public static Type[] GetParameterTypes( this MethodBase source )
+		public static Type[] GetParameterTypes(this MethodBase source)
 		{
 			var parameters = source.GetParameters();
-			Type[] parameterTypes = new Type[ parameters.Length ];
-			for ( var i = 0; i < parameters.Length; i++ )
+			Type[] parameterTypes = new Type[parameters.Length];
+			for (var i = 0; i < parameters.Length; i++)
 			{
-				parameterTypes[ i ] = parameters[ i ].ParameterType;
+				parameterTypes[i] = parameters[i].ParameterType;
 			}
 
 			return parameterTypes;
 		}
 
-		public static Type GetMemberValueType( this MemberInfo source )
+		public static Type GetMemberValueType(this MemberInfo source)
 		{
-			if ( source == null )
+			if (source == null)
 			{
-				throw new ArgumentNullException( "source" );
+				throw new ArgumentNullException("source");
 			}
 
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
 			var asType = source as Type;
-			if ( asType != null )
+			if (asType != null)
 			{
 				// Nested type.
 				return asType;
@@ -88,9 +117,9 @@ public static Type GetMemberValueType( this MemberInfo source )
 			var asProperty = source as PropertyInfo;
 			var asField = source as FieldInfo;
 
-			if ( asProperty == null && asField == null )
+			if (asProperty == null && asField == null)
 			{
-				throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "'{0}'({1}) is not field nor property.", source, source.GetType() ) );
+				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "'{0}'({1}) is not field nor property.", source, source.GetType()));
 			}
 
 			return asProperty != null ? asProperty.PropertyType : asField.FieldType;
diff --git a/src/MsgPack/Serialization/SerializationExceptions.cs b/src/MsgPack/Serialization/SerializationExceptions.cs
index e60e686ad..9a5402c80 100644
--- a/src/MsgPack/Serialization/SerializationExceptions.cs
+++ b/src/MsgPack/Serialization/SerializationExceptions.cs
@@ -1,27 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#define AOT
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 #if !UNITY || MSGPACK_UNITY_FULL
@@ -48,12 +27,12 @@ namespace MsgPack.Serialization
 	///		Defines common exception factory methods.
 	/// </summary>
 #if !UNITY || MSGPACK_UNITY_FULL
-	[EditorBrowsable( EditorBrowsableState.Never )]
+	[EditorBrowsable(EditorBrowsableState.Never)]
 #endif // !UNITY || MSGPACK_UNITY_FULL
 	public static class SerializationExceptions
 	{
 #if !AOT
-		internal static readonly MethodInfo ThrowValueTypeCannotBeNull3Method = typeof( SerializationExceptions ).GetMethod( nameof( ThrowValueTypeCannotBeNull ), new[] { typeof( string ), typeof( Type ), typeof( Type ) } );
+		internal static readonly MethodInfo ThrowValueTypeCannotBeNull3Method = typeof(SerializationExceptions).GetMethod(nameof(ThrowValueTypeCannotBeNull), new[] { typeof(string), typeof(Type), typeof(Type) });
 #endif // !AOT
 
 		/// <summary>
@@ -64,16 +43,16 @@ public static class SerializationExceptions
 		/// <param name="memberType">The type of the member.</param>
 		/// <param name="declaringType">The type that declares the member.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewValueTypeCannotBeNull( string name, Type memberType, Type declaringType )
+		public static Exception NewValueTypeCannotBeNull(string name, Type memberType, Type declaringType)
 		{
 #if DEBUG
-			Contract.Requires( !String.IsNullOrEmpty( name ) );
-			Contract.Requires( memberType != null );
-			Contract.Requires( declaringType != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(!String.IsNullOrEmpty(name));
+			Contract.Requires(memberType != null);
+			Contract.Requires(declaringType != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Member '{0}' of type '{1}' cannot be null because it is value type('{2}').", name, declaringType, memberType ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Member '{0}' of type '{1}' cannot be null because it is value type('{2}').", name, declaringType, memberType));
 		}
 
 		/// <summary>
@@ -85,9 +64,9 @@ public static Exception NewValueTypeCannotBeNull( string name, Type memberType,
 		/// <param name="declaringType">The type that declares the member.</param>
 		/// <exception cref="Exception">Always thrown.</exception>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static void ThrowValueTypeCannotBeNull( string name, Type memberType, Type declaringType )
+		public static void ThrowValueTypeCannotBeNull(string name, Type memberType, Type declaringType)
 		{
-			throw NewValueTypeCannotBeNull( name, memberType, declaringType );
+			throw NewValueTypeCannotBeNull(name, memberType, declaringType);
 		}
 
 		/// <summary>
@@ -96,14 +75,14 @@ public static void ThrowValueTypeCannotBeNull( string name, Type memberType, Typ
 		/// </summary>
 		/// <param name="type">The target type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewValueTypeCannotBeNull( Type type )
+		public static Exception NewValueTypeCannotBeNull(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot be null '{0}' type value.", type ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Cannot be null '{0}' type value.", type));
 		}
 
 		/// <summary>
@@ -112,14 +91,14 @@ public static Exception NewValueTypeCannotBeNull( Type type )
 		/// </summary>
 		/// <param name="type">The target type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewTypeCannotSerialize( Type type )
+		public static Exception NewTypeCannotSerialize(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot serialize '{0}' type.", type ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Cannot serialize '{0}' type.", type));
 		}
 
 		/// <summary>
@@ -128,14 +107,14 @@ public static Exception NewTypeCannotSerialize( Type type )
 		/// </summary>
 		/// <param name="type">The target type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewTypeCannotDeserialize( Type type )
+		public static Exception NewTypeCannotDeserialize(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot deserialize '{0}' type.", type ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Cannot deserialize '{0}' type.", type));
 		}
 
 		/// <summary>
@@ -146,16 +125,16 @@ public static Exception NewTypeCannotDeserialize( Type type )
 		/// <param name="memberName">The name of deserializing member.</param>
 		/// <param name="inner">The inner exception.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewTypeCannotDeserialize( Type type, string memberName, Exception inner )
+		public static Exception NewTypeCannotDeserialize(Type type, string memberName, Exception inner)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Requires( !String.IsNullOrEmpty( memberName ) );
-			Contract.Requires( inner != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Requires(!String.IsNullOrEmpty(memberName));
+			Contract.Requires(inner != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot deserialize member '{1}' of type '{0}'.", type, memberName ), inner );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Cannot deserialize member '{1}' of type '{0}'.", type, memberName), inner);
 		}
 
 		/// <summary>
@@ -165,16 +144,16 @@ public static Exception NewTypeCannotDeserialize( Type type, string memberName,
 		/// <param name="index">The index to be unpacking.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
 #if DEBUG
-		[Obsolete( "Use ThrowMissingItem(int, Unpacker) instead." )]
+		[Obsolete("Use ThrowMissingItem(int, Unpacker) instead.")]
 #endif
-		public static Exception NewMissingItem( int index ) // For compatibility only.
+		public static Exception NewMissingItem(int index) // For compatibility only.
 		{
 #if DEBUG
-			Contract.Requires( index >= 0 );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(index >= 0);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new InvalidMessagePackStreamException( String.Format( CultureInfo.CurrentCulture, "Items at index '{0}' is missing.", index ) );
+			return new InvalidMessagePackStreamException(String.Format(CultureInfo.CurrentCulture, "Items at index '{0}' is missing.", index));
 		}
 
 		/// <summary>
@@ -184,9 +163,9 @@ public static Exception NewMissingItem( int index ) // For compatibility only.
 		/// <param name="index">The index to be unpacking.</param>
 		/// <param name="unpacker">The unpacker for pretty message.</param>
 		/// <exception cref="Exception">Always thrown.</exception>
-		public static void ThrowMissingItem( int index, Unpacker unpacker )
+		public static void ThrowMissingItem(int index, Unpacker unpacker)
 		{
-			ThrowMissingItem( index, null, unpacker );
+			ThrowMissingItem(index, null, unpacker);
 		}
 
 		/// <summary>
@@ -197,20 +176,20 @@ public static void ThrowMissingItem( int index, Unpacker unpacker )
 		/// <param name="name">The name of the item to be unpacking.</param>
 		/// <param name="unpacker">The unpacker for pretty message.</param>
 		/// <exception cref="Exception">Always thrown.</exception>
-		public static void ThrowMissingItem( int index, string name, Unpacker unpacker )
+		public static void ThrowMissingItem(int index, string name, Unpacker unpacker)
 		{
 			long offsetOrPosition = -1;
 			bool isRealPosition = false;
-			if ( unpacker != null )
+			if (unpacker != null)
 			{
-				isRealPosition = unpacker.GetPreviousPosition( out offsetOrPosition );
+				isRealPosition = unpacker.GetPreviousPosition(out offsetOrPosition);
 			}
 
-			if ( String.IsNullOrEmpty( name ) )
+			if (String.IsNullOrEmpty(name))
 			{
-				if ( offsetOrPosition >= 0L )
+				if (offsetOrPosition >= 0L)
 				{
-					if ( isRealPosition )
+					if (isRealPosition)
 					{
 						throw new InvalidMessagePackStreamException(
 							String.Format(
@@ -238,15 +217,15 @@ public static void ThrowMissingItem( int index, string name, Unpacker unpacker )
 				else
 				{
 					throw new InvalidMessagePackStreamException(
-						String.Format( CultureInfo.CurrentCulture, "Value for '{0}' at index {1} is missing.", name, index )
+						String.Format(CultureInfo.CurrentCulture, "Value for '{0}' at index {1} is missing.", name, index)
 					);
 				}
 			}
 			else
 			{
-				if ( offsetOrPosition >= 0L )
+				if (offsetOrPosition >= 0L)
 				{
-					if ( isRealPosition )
+					if (isRealPosition)
 					{
 						throw new InvalidMessagePackStreamException(
 							String.Format(
@@ -272,19 +251,19 @@ public static void ThrowMissingItem( int index, string name, Unpacker unpacker )
 				else
 				{
 					throw new InvalidMessagePackStreamException(
-						String.Format( CultureInfo.CurrentCulture, "Item at index '{0}' is missing.", index )
+						String.Format(CultureInfo.CurrentCulture, "Item at index '{0}' is missing.", index)
 					);
 				}
 			}
 		}
 
-		internal static void ThrowMissingKey( int index, Unpacker unpacker )
+		internal static void ThrowMissingKey(int index, Unpacker unpacker)
 		{
 			long offsetOrPosition;
-			var isRealPosition = unpacker.GetPreviousPosition( out offsetOrPosition );
-			if ( offsetOrPosition >= 0L )
+			var isRealPosition = unpacker.GetPreviousPosition(out offsetOrPosition);
+			if (offsetOrPosition >= 0L)
 			{
-				if ( isRealPosition )
+				if (isRealPosition)
 				{
 					throw new InvalidMessagePackStreamException(
 						String.Format(
@@ -325,14 +304,14 @@ internal static void ThrowMissingKey( int index, Unpacker unpacker )
 		/// </summary>
 		/// <param name="type">The target type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		internal static Exception NewTargetDoesNotHavePublicDefaultConstructor( Type type )
+		internal static Exception NewTargetDoesNotHavePublicDefaultConstructor(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Type '{0}' does not have default (parameterless) public constructor.", type ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Type '{0}' does not have default (parameterless) public constructor.", type));
 		}
 
 		/// <summary>
@@ -341,19 +320,19 @@ internal static Exception NewTargetDoesNotHavePublicDefaultConstructor( Type typ
 		/// </summary>
 		/// <param name="type">The target type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		internal static Exception NewTargetDoesNotHavePublicDefaultConstructorNorInitialCapacity( Type type )
+		internal static Exception NewTargetDoesNotHavePublicDefaultConstructorNorInitialCapacity(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Type '{0}' does not have both of default (parameterless) public constructor and  public constructor with an Int32 parameter.", type ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Type '{0}' does not have both of default (parameterless) public constructor and  public constructor with an Int32 parameter.", type));
 		}
 
-		internal static void ThrowTargetDoesNotHavePublicDefaultConstructorNorInitialCapacity( Type type )
+		internal static void ThrowTargetDoesNotHavePublicDefaultConstructorNorInitialCapacity(Type type)
 		{
-			throw NewTargetDoesNotHavePublicDefaultConstructorNorInitialCapacity( type );
+			throw NewTargetDoesNotHavePublicDefaultConstructorNorInitialCapacity(type);
 		}
 
 		/// <summary>
@@ -362,20 +341,20 @@ internal static void ThrowTargetDoesNotHavePublicDefaultConstructorNorInitialCap
 		/// </summary>
 		/// <param name="name">The name of the property.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewMissingProperty( string name )
+		public static Exception NewMissingProperty(string name)
 		{
 #if DEBUG
-			Contract.Requires( !String.IsNullOrEmpty( name ) );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(!String.IsNullOrEmpty(name));
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Property '{0}' is missing.", name ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Property '{0}' is missing.", name));
 		}
 
-		internal static void ThrowMissingProperty( string name )
+		internal static void ThrowMissingProperty(string name)
 		{
 #pragma warning disable 612
-			throw NewMissingProperty( name );
+			throw NewMissingProperty(name);
 #pragma warning restore 612
 		}
 
@@ -384,23 +363,23 @@ internal static void ThrowMissingProperty( string name )
 		///		Returns new exception to notify that unpacking stream ends on unexpectedly position.
 		/// </summary>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		[Obsolete( "This method is no longer used internally. So this internal API will be removed in future." )]
+		[Obsolete("This method is no longer used internally. So this internal API will be removed in future.")]
 		public static Exception NewUnexpectedEndOfStream()
 		{
 #if DEBUG
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( "Stream unexpectedly ends." );
+			return new SerializationException("Stream unexpectedly ends.");
 		}
 
-		internal static void ThrowUnexpectedEndOfStream( Unpacker unpacker )
+		internal static void ThrowUnexpectedEndOfStream(Unpacker unpacker)
 		{
 			long offsetOrPosition;
-			var isRealPosition = unpacker.GetPreviousPosition( out offsetOrPosition );
-			if ( offsetOrPosition >= 0L )
+			var isRealPosition = unpacker.GetPreviousPosition(out offsetOrPosition);
+			if (offsetOrPosition >= 0L)
 			{
-				if ( isRealPosition )
+				if (isRealPosition)
 				{
 					throw new InvalidMessagePackStreamException(
 						String.Format(
@@ -423,7 +402,7 @@ internal static void ThrowUnexpectedEndOfStream( Unpacker unpacker )
 			}
 			else
 			{
-				throw new InvalidMessagePackStreamException( "Stream unexpectedly ends." );
+				throw new InvalidMessagePackStreamException("Stream unexpectedly ends.");
 			}
 		}
 
@@ -433,19 +412,19 @@ internal static void ThrowUnexpectedEndOfStream( Unpacker unpacker )
 		/// </summary>
 		/// <param name="type">The target type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewMissingAddMethod( Type type )
+		public static Exception NewMissingAddMethod(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Type '{0}' does not have appropriate Add method.", type ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Type '{0}' does not have appropriate Add method.", type));
 		}
 
 #if !AOT
 		internal static readonly MethodInfo ThrowIsNotArrayHeaderMethod =
-			typeof( SerializationExceptions ).GetMethod( nameof( ThrowIsNotArrayHeader ), new[] { typeof( Unpacker ) } );
+			typeof(SerializationExceptions).GetMethod(nameof(ThrowIsNotArrayHeader), new[] { typeof(Unpacker) });
 #endif // !AOT
 
 		/// <summary>
@@ -453,10 +432,10 @@ public static Exception NewMissingAddMethod( Type type )
 		///		Returns new exception to notify that unpacker is not in the array header, that is the state is invalid.
 		/// </summary>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		[Obsolete( "This method is no longer used internally. So this internal API will be removed in future." )]
+		[Obsolete("This method is no longer used internally. So this internal API will be removed in future.")]
 		public static Exception NewIsNotArrayHeader()
 		{
-			return new SerializationException( "Unpacker is not in the array header. The stream may not be array." );
+			return new SerializationException("Unpacker is not in the array header. The stream may not be array.");
 		}
 
 		/// <summary>
@@ -465,12 +444,12 @@ public static Exception NewIsNotArrayHeader()
 		/// </summary>
 		/// <param name="unpacker">The unpacker for pretty message.</param>
 		/// <exception cref="Exception">Always thrown.</exception>
-		public static void ThrowIsNotArrayHeader( Unpacker unpacker )
+		public static void ThrowIsNotArrayHeader(Unpacker unpacker)
 		{
 			long offsetOrPosition;
-			if ( unpacker != null )
+			if (unpacker != null)
 			{
-				if ( unpacker.GetPreviousPosition( out offsetOrPosition ) )
+				if (unpacker.GetPreviousPosition(out offsetOrPosition))
 				{
 					throw new SerializationException(
 						String.Format(
@@ -501,7 +480,7 @@ public static void ThrowIsNotArrayHeader( Unpacker unpacker )
 
 #if !AOT
 		internal static readonly MethodInfo ThrowIsNotMapHeaderMethod =
-			typeof( SerializationExceptions ).GetMethod( nameof( ThrowIsNotMapHeader ), new[] { typeof( Unpacker ) } );
+			typeof(SerializationExceptions).GetMethod(nameof(ThrowIsNotMapHeader), new[] { typeof(Unpacker) });
 #endif // !AOT
 
 		/// <summary>
@@ -515,10 +494,10 @@ public static void ThrowIsNotArrayHeader( Unpacker unpacker )
 		public static Exception NewIsNotMapHeader()
 		{
 #if DEBUG
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( "Unpacker is not in the map header. The stream may not be map." );
+			return new SerializationException("Unpacker is not in the map header. The stream may not be map.");
 		}
 
 		/// <summary>
@@ -527,12 +506,12 @@ public static Exception NewIsNotMapHeader()
 		/// </summary>
 		/// <param name="unpacker">The unpacker for pretty message.</param>
 		/// <exception cref="Exception">Always thrown.</exception>
-		public static void ThrowIsNotMapHeader( Unpacker unpacker )
+		public static void ThrowIsNotMapHeader(Unpacker unpacker)
 		{
 			long offsetOrPosition;
-			if ( unpacker != null )
+			if (unpacker != null)
 			{
-				if ( unpacker.GetPreviousPosition( out offsetOrPosition ) )
+				if (unpacker.GetPreviousPosition(out offsetOrPosition))
 				{
 					throw new SerializationException(
 						String.Format(
@@ -567,14 +546,14 @@ public static void ThrowIsNotMapHeader( Unpacker unpacker )
 		/// </summary>
 		/// <param name="type">Type.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewNotSupportedBecauseCannotInstanciateAbstractType( Type type )
+		public static Exception NewNotSupportedBecauseCannotInstanciateAbstractType(Type type)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(type != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new NotSupportedException( String.Format( CultureInfo.CurrentCulture, "This operation is not supported because '{0}' cannot be instanciated.", type ) );
+			return new NotSupportedException(String.Format(CultureInfo.CurrentCulture, "This operation is not supported because '{0}' cannot be instanciated.", type));
 		}
 
 #if !AOT
@@ -582,7 +561,7 @@ public static Exception NewNotSupportedBecauseCannotInstanciateAbstractType( Typ
 		///		<see cref="ThrowTupleCardinarityIsNotMatch(int,long,Unpacker)"/>
 		/// </summary>
 		internal static readonly MethodInfo ThrowTupleCardinarityIsNotMatchMethod =
-			typeof( SerializationExceptions ).GetMethod( nameof( ThrowTupleCardinarityIsNotMatch ), new[] { typeof( int ), typeof( long ), typeof( Unpacker ) } );
+			typeof(SerializationExceptions).GetMethod(nameof(ThrowTupleCardinarityIsNotMatch), new[] { typeof(int), typeof(long), typeof(Unpacker) });
 #endif // !AOT
 
 		/// <summary>
@@ -595,14 +574,14 @@ public static Exception NewNotSupportedBecauseCannotInstanciateAbstractType( Typ
 #if DEBUG
 		[Obsolete]
 #endif // DEBUG
-		public static Exception NewTupleCardinarityIsNotMatch( int expectedTupleCardinality, int actualArrayLength )
+		public static Exception NewTupleCardinarityIsNotMatch(int expectedTupleCardinality, int actualArrayLength)
 		{
 #if DEBUG
-			Contract.Requires( expectedTupleCardinality > 0 );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(expectedTupleCardinality > 0);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "The length of array ({0}) does not match to tuple cardinality ({1}).", actualArrayLength, expectedTupleCardinality ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "The length of array ({0}) does not match to tuple cardinality ({1}).", actualArrayLength, expectedTupleCardinality));
 		}
 
 		/// <summary>
@@ -617,22 +596,22 @@ public static Exception NewTupleCardinarityIsNotMatch( int expectedTupleCardinal
 		public static void ThrowTupleCardinarityIsNotMatch(
 			int expectedTupleCardinality,
 			long actualArrayLength,
-			Unpacker unpacker 
+			Unpacker unpacker
 		)
 		{
 #if DEBUG
-			Contract.Requires( expectedTupleCardinality > 0 );
+			Contract.Requires(expectedTupleCardinality > 0);
 #endif // DEBUG
 			long offsetOrPosition = -1;
 			bool isRealPosition = false;
-			if ( unpacker != null )
+			if (unpacker != null)
 			{
-				isRealPosition = unpacker.GetPreviousPosition( out offsetOrPosition );
+				isRealPosition = unpacker.GetPreviousPosition(out offsetOrPosition);
 			}
 
-			if ( offsetOrPosition >= 0L )
+			if (offsetOrPosition >= 0L)
 			{
-				if ( isRealPosition )
+				if (isRealPosition)
 				{
 					throw new InvalidMessagePackStreamException(
 						String.Format(
@@ -676,18 +655,18 @@ Unpacker unpacker
 		/// </summary>
 		/// <param name="innerException">The inner exception for the debug. The value is implementation specific.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewIsIncorrectStream( Exception innerException )
+		public static Exception NewIsIncorrectStream(Exception innerException)
 		{
 #if DEBUG
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( "Failed to unpack items count of the collection.", innerException );
+			return new SerializationException("Failed to unpack items count of the collection.", innerException);
 		}
 
-		internal static void ThrowIsIncorrectStream( Exception innerException )
+		internal static void ThrowIsIncorrectStream(Exception innerException)
 		{
-			throw NewIsIncorrectStream( innerException );
+			throw NewIsIncorrectStream(innerException);
 		}
 
 		/// <summary>
@@ -698,10 +677,10 @@ internal static void ThrowIsIncorrectStream( Exception innerException )
 		public static Exception NewIsTooLargeCollection()
 		{
 #if DEBUG
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new MessageNotSupportedException( "The collection which has more than Int32.MaxValue items is not supported." );
+			return new MessageNotSupportedException("The collection which has more than Int32.MaxValue items is not supported.");
 		}
 
 		internal static void ThrowIsTooLargeCollection()
@@ -710,7 +689,7 @@ internal static void ThrowIsTooLargeCollection()
 		}
 
 #if !AOT
-		internal static readonly MethodInfo ThrowNullIsProhibitedMethod = typeof( SerializationExceptions ).GetMethod( nameof( ThrowNullIsProhibited ), new[] { typeof( string ) } );
+		internal static readonly MethodInfo ThrowNullIsProhibitedMethod = typeof(SerializationExceptions).GetMethod(nameof(ThrowNullIsProhibited), new[] { typeof(string) });
 #endif // !AOT
 
 		/// <summary>
@@ -719,14 +698,14 @@ internal static void ThrowIsTooLargeCollection()
 		/// </summary>
 		/// <param name="memberName">The name of the member.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewNullIsProhibited( string memberName )
+		public static Exception NewNullIsProhibited(string memberName)
 		{
 #if DEBUG
-			Contract.Requires( !String.IsNullOrEmpty( memberName ) );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(!String.IsNullOrEmpty(memberName));
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "The member '{0}' cannot be nil.", memberName ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "The member '{0}' cannot be nil.", memberName));
 		}
 
 		/// <summary>
@@ -735,9 +714,9 @@ public static Exception NewNullIsProhibited( string memberName )
 		/// </summary>
 		/// <param name="memberName">The name of the member.</param>
 		/// <exception cref="Exception">Always thrown.</exception>
-		public static void ThrowNullIsProhibited( string memberName )
+		public static void ThrowNullIsProhibited(string memberName)
 		{
-			throw NewNullIsProhibited( memberName );
+			throw NewNullIsProhibited(memberName);
 		}
 
 		/// <summary>
@@ -746,14 +725,14 @@ public static void ThrowNullIsProhibited( string memberName )
 		/// </summary>
 		/// <param name="memberName">The name of the member.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewReadOnlyMemberItemsMustNotBeNull( string memberName )
+		public static Exception NewReadOnlyMemberItemsMustNotBeNull(string memberName)
 		{
 #if DEBUG
-			Contract.Requires( !String.IsNullOrEmpty( memberName ) );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(!String.IsNullOrEmpty(memberName));
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "The member '{0}' cannot be nil because it is read only member.", memberName ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "The member '{0}' cannot be nil because it is read only member.", memberName));
 		}
 
 		/// <summary>
@@ -762,14 +741,14 @@ public static Exception NewReadOnlyMemberItemsMustNotBeNull( string memberName )
 		/// </summary>
 		/// <param name="memberName">The name of the member.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewStreamDoesNotContainCollectionForMember( string memberName )
+		public static Exception NewStreamDoesNotContainCollectionForMember(string memberName)
 		{
 #if DEBUG
-			Contract.Requires( !String.IsNullOrEmpty( memberName ) );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(!String.IsNullOrEmpty(memberName));
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot deserialize member '{0}' because the underlying stream does not contain collection.", memberName ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Cannot deserialize member '{0}' because the underlying stream does not contain collection.", memberName));
 		}
 
 		/// <summary>
@@ -779,15 +758,15 @@ public static Exception NewStreamDoesNotContainCollectionForMember( string membe
 		/// <param name="expectedLength">Expected, required for deserialization array length.</param>
 		/// <param name="actualLength">Actual array length.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewUnexpectedArrayLength( int expectedLength, int actualLength )
+		public static Exception NewUnexpectedArrayLength(int expectedLength, int actualLength)
 		{
 #if DEBUG
-			Contract.Requires( expectedLength >= 0 );
-			Contract.Requires( actualLength >= 0 );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(expectedLength >= 0);
+			Contract.Requires(actualLength >= 0);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "The MessagePack stream is invalid. Expected array length is {0}, but actual is {1}.", expectedLength, actualLength ) );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "The MessagePack stream is invalid. Expected array length is {0}, but actual is {1}.", expectedLength, actualLength));
 		}
 
 		/// <summary>
@@ -798,16 +777,16 @@ public static Exception NewUnexpectedArrayLength( int expectedLength, int actual
 		/// <param name="memberName">The name of the deserializing member.</param>
 		/// <param name="inner">The exception which caused current error.</param>
 		/// <returns><see cref="Exception"/> instance. It will not be <c>null</c>.</returns>
-		public static Exception NewFailedToDeserializeMember( Type targetType, string memberName, Exception inner )
+		public static Exception NewFailedToDeserializeMember(Type targetType, string memberName, Exception inner)
 		{
 #if DEBUG
-			Contract.Requires( targetType != null );
-			Contract.Requires( !String.IsNullOrEmpty( memberName ) );
-			Contract.Requires( inner != null );
-			Contract.Ensures( Contract.Result<Exception>() != null );
+			Contract.Requires(targetType != null);
+			Contract.Requires(!String.IsNullOrEmpty(memberName));
+			Contract.Requires(inner != null);
+			Contract.Ensures(Contract.Result<Exception>() != null);
 #endif // DEBUG
 
-			return new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot deserialize member '{0}' of type '{1}'.", memberName, targetType ), inner );
+			return new SerializationException(String.Format(CultureInfo.CurrentCulture, "Cannot deserialize member '{0}' of type '{1}'.", memberName, targetType), inner);
 		}
 
 		/// <summary>
@@ -816,9 +795,9 @@ public static Exception NewFailedToDeserializeMember( Type targetType, string me
 		/// <param name="targetType">Deserializing type.</param>
 		/// <param name="memberName">The name of the deserializing member.</param>
 		/// <param name="inner">The exception which caused current error.</param>
-		internal static void ThrowFailedToDeserializeMember( Type targetType, string memberName, Exception inner )
+		internal static void ThrowFailedToDeserializeMember(Type targetType, string memberName, Exception inner)
 		{
-			throw NewFailedToDeserializeMember( targetType, memberName, inner );
+			throw NewFailedToDeserializeMember(targetType, memberName, inner);
 		}
 
 #if !AOT
@@ -826,7 +805,7 @@ internal static void ThrowFailedToDeserializeMember( Type targetType, string mem
 		///		<see cref="NewUnpackFromIsNotSupported(Type)"/>
 		/// </summary>
 		internal static readonly MethodInfo NewUnpackFromIsNotSupportedMethod =
-			typeof( SerializationExceptions ).GetMethod( nameof( NewUnpackFromIsNotSupported ), new[] { typeof( Type ) } );
+			typeof(SerializationExceptions).GetMethod(nameof(NewUnpackFromIsNotSupported), new[] { typeof(Type) });
 #endif // !AOT
 
 		/// <summary>
@@ -834,12 +813,12 @@ internal static void ThrowFailedToDeserializeMember( Type targetType, string mem
 		/// </summary>
 		/// <param name="targetType">Deserializing type.</param>
 		/// <returns>The exception. This value will not be <c>null</c>.</returns>
-		public static Exception NewUnpackFromIsNotSupported( Type targetType )
+		public static Exception NewUnpackFromIsNotSupported(Type targetType)
 		{
 #if DEBUG
-			Contract.Requires( targetType != null );
+			Contract.Requires(targetType != null);
 #endif // DEBUG
-			return new NotSupportedException( String.Format( CultureInfo.CurrentCulture, "This operation is not supported for '{0}' because the serializer does not support UnpackFrom method.", targetType ) );
+			return new NotSupportedException(String.Format(CultureInfo.CurrentCulture, "This operation is not supported for '{0}' because the serializer does not support UnpackFrom method.", targetType));
 		}
 
 #if !AOT
@@ -847,7 +826,7 @@ public static Exception NewUnpackFromIsNotSupported( Type targetType )
 		///		<see cref="NewCreateInstanceIsNotSupported(Type)"/>
 		/// </summary>
 		internal static readonly MethodInfo NewCreateInstanceIsNotSupportedMethod =
-			typeof( SerializationExceptions ).GetMethod( nameof( NewCreateInstanceIsNotSupported ), new[] { typeof( Type ) } );
+			typeof(SerializationExceptions).GetMethod(nameof(NewCreateInstanceIsNotSupported), new[] { typeof(Type) });
 #endif // !AOT
 
 		/// <summary>
@@ -855,36 +834,36 @@ public static Exception NewUnpackFromIsNotSupported( Type targetType )
 		/// </summary>
 		/// <param name="targetType">Deserializing type.</param>
 		/// <returns>The exception. This value will not be <c>null</c>.</returns>
-		public static Exception NewCreateInstanceIsNotSupported( Type targetType )
+		public static Exception NewCreateInstanceIsNotSupported(Type targetType)
 		{
 #if DEBUG
-			Contract.Requires( targetType != null );
+			Contract.Requires(targetType != null);
 #endif // DEBUG
-			return new NotSupportedException( String.Format( CultureInfo.CurrentCulture, "This operation is not supported for '{0}' because the serializer does not support CreateInstance method.", targetType ) );
+			return new NotSupportedException(String.Format(CultureInfo.CurrentCulture, "This operation is not supported for '{0}' because the serializer does not support CreateInstance method.", targetType));
 		}
 
-		internal static Exception NewUnpackToIsNotSupported( Type type, Exception inner )
+		internal static Exception NewUnpackToIsNotSupported(Type type, Exception inner)
 		{
 #if DEBUG
-			Contract.Requires( type != null );
+			Contract.Requires(type != null);
 #endif // DEBUG
-			return new NotSupportedException( String.Format( CultureInfo.CurrentCulture, "This operation is not supported for '{0}' because it does not have accesible Add(T) method.", type ), inner );
+			return new NotSupportedException(String.Format(CultureInfo.CurrentCulture, "This operation is not supported for '{0}' because it does not have accesible Add(T) method.", type), inner);
 		}
 
-		internal static Exception NewValueTypeCannotBePolymorphic( Type type )
+		internal static Exception NewValueTypeCannotBePolymorphic(Type type)
 		{
 			return
 				new SerializationException(
-					String.Format( CultureInfo.CurrentCulture, "Value type '{0}' cannot be polymorphic.", type )
+					String.Format(CultureInfo.CurrentCulture, "Value type '{0}' cannot be polymorphic.", type)
 				);
 		}
 
 		internal static Exception NewUnknownTypeEmbedding()
 		{
-			return new SerializationException( "Cannot deserialize with type-embedding based serializer. Root object must be 3 element array." );
+			return new SerializationException("Cannot deserialize with type-embedding based serializer. Root object must be 3 element array.");
 		}
 
-		internal static Exception NewIncompatibleCollectionSerializer( Type targetType, Type incompatibleType, Type exampleClass )
+		internal static Exception NewIncompatibleCollectionSerializer(Type targetType, Type incompatibleType, Type exampleClass)
 		{
 			return
 				new SerializationException(
@@ -893,45 +872,45 @@ internal static Exception NewIncompatibleCollectionSerializer( Type targetType,
 						"Cannot serialize type '{0}' because registered or generated serializer '{1}' does not implement '{2}', which is implemented by '{3}', for example.",
 						targetType.GetFullName(),
 						incompatibleType.GetFullName(),
-						typeof( ICollectionInstanceFactory ),
+						typeof(ICollectionInstanceFactory),
 						exampleClass.GetFullName()
 					)
 				);
 		}
 
-		internal static void ThrowArgumentNullException( string parameterName )
+		internal static void ThrowArgumentNullException(string parameterName)
 		{
-			throw new ArgumentNullException( parameterName );
+			throw new ArgumentNullException(parameterName);
 		}
 
-		internal static void ThrowArgumentNullException( string parameterName, string fieldName )
+		internal static void ThrowArgumentNullException(string parameterName, string fieldName)
 		{
-			throw new ArgumentNullException( parameterName, String.Format( CultureInfo.CurrentCulture, "Field '{0}' of parameter '{1}' cannot be null.", fieldName, parameterName ) );
+			throw new ArgumentNullException(parameterName, String.Format(CultureInfo.CurrentCulture, "Field '{0}' of parameter '{1}' cannot be null.", fieldName, parameterName));
 		}
 
-		internal static void ThrowArgumentCannotBeNegativeException( string parameterName )
+		internal static void ThrowArgumentCannotBeNegativeException(string parameterName)
 		{
-			throw new ArgumentOutOfRangeException( parameterName, "The value cannot be negative number." );
+			throw new ArgumentOutOfRangeException(parameterName, "The value cannot be negative number.");
 		}
 
-		internal static void ThrowArgumentCannotBeNegativeException( string parameterName, string fieldName )
+		internal static void ThrowArgumentCannotBeNegativeException(string parameterName, string fieldName)
 		{
-			throw new ArgumentOutOfRangeException( parameterName, String.Format( CultureInfo.CurrentCulture, "Field '{0}' of parameter '{1}' cannot be negative number.", fieldName, parameterName ) );
+			throw new ArgumentOutOfRangeException(parameterName, String.Format(CultureInfo.CurrentCulture, "Field '{0}' of parameter '{1}' cannot be negative number.", fieldName, parameterName));
 		}
 
-		internal static void ThrowArgumentException( string parameterName, string message )
+		internal static void ThrowArgumentException(string parameterName, string message)
 		{
-			throw new ArgumentException( message, parameterName );
+			throw new ArgumentException(message, parameterName);
 		}
 
-		internal static void ThrowSerializationException( string message )
+		internal static void ThrowSerializationException(string message)
 		{
-			throw new SerializationException( message );
+			throw new SerializationException(message);
 		}
 
-		internal static void ThrowSerializationException( string message, Exception innerException )
+		internal static void ThrowSerializationException(string message, Exception innerException)
 		{
-			throw new SerializationException( message, innerException );
+			throw new SerializationException(message, innerException);
 		}
 
 #if UNITY && DEBUG
@@ -939,7 +918,7 @@ internal static void ThrowSerializationException( string message, Exception inne
 #else
 		internal
 #endif
-		static void ThrowInvalidArrayItemsCount( Unpacker unpacker, Type targetType, int requiredCount )
+		static void ThrowInvalidArrayItemsCount(Unpacker unpacker, Type targetType, int requiredCount)
 		{
 			throw
 				unpacker.IsCollectionHeader
diff --git a/src/MsgPack/Serialization/SerializationMethodGeneratorOption.cs b/src/MsgPack/Serialization/SerializationMethodGeneratorOption.cs
index 00aa73fad..5c0fec167 100644
--- a/src/MsgPack/Serialization/SerializationMethodGeneratorOption.cs
+++ b/src/MsgPack/Serialization/SerializationMethodGeneratorOption.cs
@@ -1,26 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 #if !UNITY || MSGPACK_UNITY_FULL
@@ -32,25 +12,22 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Define options of serializer generation.
 	/// </summary>
+	[Obsolete("This type has not been used.")]
+	[EditorBrowsable(EditorBrowsableState.Never)]
 	public enum SerializationMethodGeneratorOption
 	{
-#if !SILVERLIGHT
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
 		/// <summary>
 		///		The generated method IL can be dumped to the current directory.
 		///		It is intended for the runtime, you cannot use this option.
 		/// </summary>
-#if !UNITY || MSGPACK_UNITY_FULL
 		[EditorBrowsable( EditorBrowsableState.Never )]
-#endif // !UNITY || MSGPACK_UNITY_FULL
 		CanDump,
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
 
+		// TODO: AssemblyLoadContext support for CanCollect work properly.
 		/// <summary>
 		///		The entire generated method can be collected by GC when it is no longer used.
 		/// </summary>
 		CanCollect,
-#endif // !SILVERLIGHT
 
 		/// <summary>
 		///		Prefer performance. This options is default.
diff --git a/src/MsgPack/Serialization/SerializationTarget.cs b/src/MsgPack/Serialization/SerializationTarget.cs
index 8efe8ab1b..20a9e77bd 100644
--- a/src/MsgPack/Serialization/SerializationTarget.cs
+++ b/src/MsgPack/Serialization/SerializationTarget.cs
@@ -1,125 +1,98 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2014-2018 FUJIWARA, Yusuke and contributors
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-// Contributors:
-//    Takeshi KIRIYA
-//    Odyth
-//    Roman-Blinkov
-//    Samuel Cragg
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
-using System.Globalization;
 using System.Linq;
 using System.Reflection;
-using System.Runtime.Serialization;
 
-using MsgPack.Serialization.DefaultSerializers;
+#warning TODO: Implement generator and reflection with this type!
+#warning TODO: Separate factory method from this file for maintenancibility.
 
 namespace MsgPack.Serialization
 {
 	/// <summary>
 	///		Implements serialization target member extraction logics.
 	/// </summary>
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	class SerializationTarget
+	internal readonly struct SerializationTarget
 	{
 		// Type names to avoid user who doesn't embed "message pack assembly's attributes" in their code directly.
-		private static readonly string MessagePackMemberAttributeTypeName = typeof( MessagePackMemberAttribute ).FullName;
-		private static readonly string MessagePackIgnoreAttributeTypeName = typeof( MessagePackIgnoreAttribute ).FullName;
-		private static readonly string MessagePackDeserializationConstructorAttributeTypeName = typeof( MessagePackDeserializationConstructorAttribute ).FullName;
-		private static readonly string[] EmptyStrings = new string[ 0 ];
-		private static readonly SerializingMember[] EmptyMembers = new SerializingMember[ 0 ];
-		private static readonly Assembly ThisAssembly = typeof( SerializationTarget ).GetAssembly();
+		private static readonly string MessagePackMemberAttributeTypeName = typeof(MessagePackMemberAttribute).FullName!;
+		private static readonly string MessagePackIgnoreAttributeTypeName = typeof(MessagePackIgnoreAttribute).FullName!;
+		private static readonly string MessagePackDeserializationConstructorAttributeTypeName = typeof(MessagePackDeserializationConstructorAttribute).FullName!;
+		private static readonly Assembly ThisAssembly = typeof(SerializationTarget).GetAssembly();
+
+		public Type Type { get; }
 
-		public IList<SerializingMember> Members { get; private set; }
+		public CollectionTraits CollectionTraits { get; }
 
-		public ConstructorInfo DeserializationConstructor { get; private set; }
+		public IReadOnlyList<SerializingMember> Members { get; }
 
-		private readonly string[] _correspondingMemberNames;
+		public ConstructorInfo? DeserializationConstructor { get; }
 
-		public bool IsConstructorDeserialization { get; private set; }
+		private readonly string?[]? _correspondentMemberNames;
 
-		public bool CanDeserialize { get; private set; }
+		public bool IsConstructorDeserialization => (this.DeserializationConstructor?.GetParameters()?.Length).GetValueOrDefault() > 0;
 
-		private SerializationTarget( IList<SerializingMember> members, ConstructorInfo constructor, string[] correspondingMemberNames, bool canDeserialize )
+		public bool CanDeserialize { get; }
+
+		public bool IsCollection => this.CollectionTraits.CollectionType != CollectionKind.NotCollection;
+
+		private SerializationTarget(Type type, CollectionTraits traits, IReadOnlyList<SerializingMember> members, ConstructorInfo? constructor, string?[]? correspondentMemberNames, bool canDeserialize)
 		{
-			Trace( "SerializationTarget::ctor(canDeserialize: {0})", canDeserialize );
+			this.Type = type;
+			this.CollectionTraits = traits;
 			this.Members = members;
 			this.DeserializationConstructor = constructor;
-			this.IsConstructorDeserialization = constructor != null && constructor.GetParameters().Any();
 			this.CanDeserialize = canDeserialize;
-			this._correspondingMemberNames = correspondingMemberNames ?? EmptyStrings;
-		}
-
-		public SerializerCapabilities GetCapabilitiesForObject()
-		{
-			return this.CanDeserialize ? ( SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom ) : SerializerCapabilities.PackTo;
-		}
-
-		public SerializerCapabilities GetCapabilitiesForCollection( CollectionTraits traits )
-		{
-			return
-				!this.CanDeserialize
-					? SerializerCapabilities.PackTo
-					: traits.AddMethod == null
-						? ( SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom )
-						: ( SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom | SerializerCapabilities.UnpackTo );
-		}
+			this._correspondentMemberNames = correspondentMemberNames;
+		}
+
+		public SerializerCapabilities GetCapabilities()
+			=> TupleItems.IsTuple(this.Type) ?
+				(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) :
+				this.IsCollection ?
+					(
+						!this.CanDeserialize ?
+							SerializerCapabilities.Serialize :
+							this.CollectionTraits.AddMethod == null ?
+								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) :
+								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize | SerializerCapabilities.DeserializeTo)
+					) :
+					(
+						!this.CanDeserialize?
+							SerializerCapabilities.Serialize :
+							this.Type.GetIsValueType() ?
+								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) :
+								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize | SerializerCapabilities.DeserializeTo)
+					);
 
-		private static string[] FindCorrespondingMemberNames( IList<SerializingMember> members, ConstructorInfo constructor )
+		private static string?[]? FindCorrespondentMemberNames(IReadOnlyList<SerializingMember> members, ConstructorInfo? constructor)
 		{
-			if ( constructor == null )
+			if (constructor == null)
 			{
 				return null;
 			}
 
+			Debug.Assert(!members.Any(m => m.Member == null), "members contains Tuple item.");
+
 			var constructorParameters = constructor.GetParameters();
 			return
 					constructorParameters.GroupJoin(
 						members,
-						p => new KeyValuePair<string, Type>( p.Name, p.ParameterType ),
-						m => new KeyValuePair<string, Type>( m.Contract.Name, m.Member == null ? null : m.Member.GetMemberValueType() ),
-						( p, ms ) => DetermineCorrespondingMemberName( p, ms ),
+						p => new KeyValuePair<string, Type>(p.Name!, p.ParameterType),
+						m => new KeyValuePair<string, Type>(m.Contract.Name, m.Member!.GetMemberValueType()),
+						(p, ms) => DetermineCorrespondentMemberName(p, ms),
 						MemberConstructorParameterEqualityComparer.Instance
 					).ToArray();
 		}
 
-		private static string DetermineCorrespondingMemberName( ParameterInfo parameterInfo, IEnumerable<SerializingMember> members )
+		private static string? DetermineCorrespondentMemberName(ParameterInfo parameterInfo, IEnumerable<SerializingMember> members)
 		{
 			var membersArray = members.ToArray();
-			switch ( membersArray.Length )
+			switch (membersArray.Length)
 			{
 				case 0:
 				{
@@ -127,88 +100,72 @@ private static string DetermineCorrespondingMemberName( ParameterInfo parameterI
 				}
 				case 1:
 				{
-					return membersArray[ 0 ].MemberName;
+					return membersArray[0].MemberName;
 				}
 				default:
 				{
-					ThrowAmbigiousMatchException( parameterInfo, membersArray );
-					return null;
+					ThrowAmbigiousMatchException(parameterInfo, membersArray);
+					// never
+					return default!;
 				}
 			}
 		}
 
-		private static void ThrowAmbigiousMatchException( ParameterInfo parameterInfo, ICollection<SerializingMember> members )
-		{
+		private static void ThrowAmbigiousMatchException(ParameterInfo parameterInfo, ICollection<SerializingMember> members) =>
 			throw new AmbiguousMatchException(
-				String.Format(
-					CultureInfo.CurrentCulture,
-					"There are multiple candiates for corresponding member for parameter '{0}' of constructor. [{1}]",
-					parameterInfo,
-					String.Join( ", ", members.Select( x => x.ToString() ).ToArray() )
-				)
+				$"There are multiple candiates for corresponding member for parameter '{parameterInfo}' of constructor. [{String.Join(", ", members.Select(x => x.ToString()))}]"
 			);
-		}
 
-		public string GetCorrespondingMemberName( int constructorParameterIndex )
-		{
-			return this._correspondingMemberNames[ constructorParameterIndex ];
-		}
+		public string? GetCorrespondentMemberName(int constructorParameterIndex)
+			=> this._correspondentMemberNames?[constructorParameterIndex];
 
-		public static void VerifyType( Type targetType )
+		public static void VerifyType(Type targetType)
 		{
-			if ( targetType.GetIsInterface() || targetType.GetIsAbstract() )
+			if (targetType.GetIsInterface() || targetType.GetIsAbstract())
 			{
-				throw SerializationExceptions.NewNotSupportedBecauseCannotInstanciateAbstractType( targetType );
+				Throw.NotSupportedBecauseCannotInstanciateAbstractType(targetType);
 			}
 		}
 
-		public static void VerifyCanSerializeTargetType( SerializationContext context, Type targetType )
+		public static void VerifyCanSerializeTargetType(SerializerGenerationOptions options, Type targetType)
 		{
-			if ( context.SerializerOptions.DisablePrivilegedAccess && !targetType.GetIsPublic() && !targetType.GetIsNestedPublic() && !ThisAssembly.Equals( targetType.GetAssembly() ) )
+			if (options.DisablesPrivilegedAccess && !targetType.GetIsPublic() && !targetType.GetIsNestedPublic() && !ThisAssembly.Equals(targetType.GetAssembly()))
 			{
-				throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot serialize type '{0}' because it is not public to the serializer.", targetType ) );
+				Throw.CannotSerializeNonPublicTypeUnlessPrivledgedAccessEnabled(targetType);
 			}
 		}
 
-		public static SerializationTarget Prepare( SerializationContext context, Type targetType )
+		public static SerializationTarget Prepare(DiagnosticListener diag, SerializerGenerationOptions options, Type targetType)
 		{
-			VerifyCanSerializeTargetType( context, targetType );
+			VerifyCanSerializeTargetType(options, targetType);
 
-			IEnumerable<string> memberIgnoreList = context.BindingOptions.GetIgnoringMembers( targetType );
-			var getters = GetTargetMembers( targetType )
-						  .Where( getter => !memberIgnoreList.Contains( getter.MemberName, StringComparer.Ordinal ) )
-						  .OrderBy( entry => entry.Contract.Id )
+			var memberIgnoreList = options.IgnoringMembers.TryGetValue(targetType, out var ignoringMembers) ? ignoringMembers : Enumerable.Empty<string>();
+			var getters = GetTargetMembers(targetType, options)
+						  .Where(getter => !memberIgnoreList.Contains(getter.MemberName, StringComparer.Ordinal))
+						  .OrderBy(entry => entry.Contract.Id)
 						  .ToArray();
 
-			if ( getters.Length == 0
-				&& !typeof( IPackable ).IsAssignableFrom( targetType )
-				&& !typeof( IUnpackable ).IsAssignableFrom( targetType )
-#if FEATURE_TAP
-				&& ( context.SerializerOptions.WithAsync
-					&& ( !typeof( IAsyncPackable ).IsAssignableFrom( targetType )
-						&& !typeof( IAsyncUnpackable ).IsAssignableFrom( targetType )
-					)
-				)
-#endif // FEATURE_TAP
-			)
+			if (getters.Length == 0 && !options.SerializableAnywayInterfaceDetector(targetType, options))
 			{
-				throw new SerializationException( String.Format( CultureInfo.CurrentCulture, "Cannot serialize type '{0}' because it does not have any serializable fields nor properties.", targetType ) );
+				Throw.IsNotSerializableAnyway(targetType);
 			}
 
-			var memberCandidates = getters.Where( entry => CheckTargetEligibility( context, entry.Member ) ).ToArray();
+			var memberCandidates = getters.Where(entry => CheckTargetEligibility(options, entry.Member!)).ToArray();
 
-			if ( memberCandidates.Length == 0 && !context.CompatibilityOptions.AllowAsymmetricSerializer )
+			if (memberCandidates.Length == 0 && !options.AllowsAsymmetricSerializer)
 			{
 				ConstructorKind constructorKind;
-				var deserializationConstructor = FindDeserializationConstructor( context, targetType, out constructorKind );
-				var complementedMembers = ComplementMembers( getters, context, targetType );
-				var correspondingMemberNames = FindCorrespondingMemberNames( complementedMembers, deserializationConstructor );
+				var deserializationConstructor = FindDeserializationConstructor(diag, options, targetType, out constructorKind);
+				var complementedMembers = ComplementMembers(getters, options, targetType);
+				var correspondingMemberNames = FindCorrespondentMemberNames(complementedMembers, deserializationConstructor);
 				return
 					new SerializationTarget(
+						targetType,
+						CollectionTraits.NotCollection,
 						complementedMembers,
 						deserializationConstructor,
 						correspondingMemberNames,
-						DetermineCanDeserialize( constructorKind, context, targetType, correspondingMemberNames, allowDefault: false )
+						DetermineCanDeserialize(diag, constructorKind, options, targetType, correspondingMemberNames, allowDefault: false)
 					);
 			}
 			else
@@ -217,24 +174,22 @@ public static SerializationTarget Prepare( SerializationContext context, Type ta
 				ConstructorKind constructorKind;
 
 				// Try to get default constructor.
-				var constructor = targetType.GetConstructor( ReflectionAbstractions.EmptyTypes );
-				if ( constructor == null && !targetType.GetIsValueType() )
+				var constructor = targetType.GetConstructor(ReflectionAbstractions.EmptyTypes);
+				if (constructor == null && !targetType.GetIsValueType())
 				{
 					// Try to get deserialization constructor.
-					var deserializationConstructor = FindDeserializationConstructor( context, targetType, out constructorKind );
-					if ( deserializationConstructor == null && !context.CompatibilityOptions.AllowAsymmetricSerializer )
+					var deserializationConstructor = FindDeserializationConstructor(diag, options, targetType, out constructorKind);
+					if (deserializationConstructor == null && !options.AllowsAsymmetricSerializer)
 					{
-						throw SerializationExceptions.NewTargetDoesNotHavePublicDefaultConstructor( targetType );
+						Throw.TargetDoesNotHavePublicDefaultConstructor(targetType);
 					}
 
 					constructor = deserializationConstructor;
 					canDeserialize = null;
 				}
-				else if ( memberCandidates.Length == 0 )
+				else if (memberCandidates.Length == 0)
 				{
-#if DEBUG
-					Contract.Assert( context.CompatibilityOptions.AllowAsymmetricSerializer );
-#endif // DEBUG
+					Debug.Assert(options.AllowsAsymmetricSerializer);
 					// Absolutely cannot deserialize in this case.
 					canDeserialize = false;
 					constructorKind = ConstructorKind.Ambiguous;
@@ -243,12 +198,12 @@ public static SerializationTarget Prepare( SerializationContext context, Type ta
 				{
 					constructorKind = ConstructorKind.Default;
 					// Let's prefer annotated constructor here.
-					var markedConstructors = FindExplicitDeserializationConstructors( targetType.GetConstructors() );
-					if ( markedConstructors.Count == 1 )
+					var markedConstructors = FindExplicitDeserializationConstructors(targetType.GetConstructors());
+					if (markedConstructors.Count == 1)
 					{
 						// For backward compatibility, no exceptions are thrown here even if mulitiple deserialization constructor attributes in the type
 						// just use default constructor for it.
-						constructor = markedConstructors[ 0 ];
+						constructor = markedConstructors[0];
 						constructorKind = ConstructorKind.Marked;
 					}
 
@@ -256,108 +211,124 @@ public static SerializationTarget Prepare( SerializationContext context, Type ta
 					canDeserialize = true;
 				}
 
-				if ( constructor != null && constructor.GetParameters().Any() || context.CompatibilityOptions.AllowAsymmetricSerializer )
+				if (constructor != null && constructor.GetParameters().Any() || options.AllowsAsymmetricSerializer)
 				{
 					// Recalculate members because getter-only/readonly members should be included for constructor deserialization.
 					memberCandidates = getters;
 				}
 
 				// Because members' order is equal to declared order is NOT guaranteed, so explicit ordering is required.
-				IList<SerializingMember> members;
-				if ( memberCandidates.All( item => item.Contract.Id == DataMemberContract.UnspecifiedId ) )
+				IReadOnlyList<SerializingMember> members;
+				if (memberCandidates.All(item => item.Contract.Id == DataMemberContract.UnspecifiedId))
 				{
 					// Alphabetical order.
-					members = memberCandidates.OrderBy( item => item.Contract.Name ).ToArray();
+					members = memberCandidates.OrderBy(item => item.Contract.Name).ToArray();
 				}
 				else
 				{
 					// ID order.
-					members = ComplementMembers( memberCandidates, context, targetType );
+					members = ComplementMembers(memberCandidates, options, targetType);
 				}
 
-				var correspondingMemberNames = FindCorrespondingMemberNames( members, constructor );
+				var correspondingMemberNames = FindCorrespondentMemberNames(members, constructor);
 				return
 					new SerializationTarget(
+						targetType,
+						CollectionTraits.NotCollection,
 						members,
 						constructor,
 						correspondingMemberNames,
-						canDeserialize ?? DetermineCanDeserialize( constructorKind, context, targetType, correspondingMemberNames, allowDefault: true )
+						canDeserialize ?? DetermineCanDeserialize(diag, constructorKind, options, targetType, correspondingMemberNames, allowDefault: true)
 					);
 			}
 		}
 
-		private static bool HasAnyCorrespondingMembers( IEnumerable<string> correspondingMemberNames )
-		{
-			return correspondingMemberNames.Count( x => !String.IsNullOrEmpty( x ) ) > 0;
-		}
+		private static bool HasAnyCorrespondingMembers(IEnumerable<string?> correspondingMemberNames)
+			=> correspondingMemberNames.Count(x => !String.IsNullOrEmpty(x)) > 0;
 
-		private static bool HasUnpackableInterface( Type targetType, SerializationContext context )
-		{
-			return
-				typeof( IUnpackable ).IsAssignableFrom( targetType )
-#if FEATURE_TAP
-						&& ( !context.SerializerOptions.WithAsync || typeof( IAsyncUnpackable ).IsAssignableFrom( targetType ) )
-#endif // FEATURE_TAP
-						;
-		}
+		private static bool HasDeserializableInterface(Type targetType, SerializerGenerationOptions options)
+			=> options.DeserializableInterfaceDetector(targetType, options);
 
-		private static bool DetermineCanDeserialize( ConstructorKind kind, SerializationContext context, Type targetType, IEnumerable<string> correspondingMemberNames, bool allowDefault )
+		private static bool DetermineCanDeserialize(DiagnosticSource diag, ConstructorKind kind, SerializerGenerationOptions options, Type targetType, IEnumerable<string?> correspondingMemberNames, bool allowDefault)
 		{
-			if ( HasUnpackableInterface( targetType, context ) )
+			if (HasDeserializableInterface(targetType, options))
 			{
-				Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> true: HasUnpackableInterface", targetType, kind );
+				diag.DetectedAsDeserializable(
+					new
+					{
+						targetType,
+						constructorKind = "ImplementsInterface",
+						allowsDefault = allowDefault
+					}
+				);
 				return true;
 			}
 
-			switch ( kind )
+			switch (kind)
 			{
 				case ConstructorKind.Marked:
 				{
-					Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> true: Marked", targetType, kind );
+					diag.DetectedAsDeserializable(
+						new
+						{
+							targetType,
+							constructorKind = "MarkedWithAttribute",
+							allowsDefault = allowDefault
+						}
+					);
 					return true;
 				}
 				case ConstructorKind.Parameterful:
 				{
-					var result = HasAnyCorrespondingMembers( correspondingMemberNames );
-					Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> {2}: HasAnyCorrespondingMembers", targetType, kind, result );
+					var result = HasAnyCorrespondingMembers(correspondingMemberNames);
+					diag.DetectedAsDeserializable(
+						new
+						{
+							targetType,
+							constructorKind = "Parameterful",
+							allowsDefault = allowDefault
+						}
+					);
 					return result;
 				}
 				case ConstructorKind.Default:
 				{
-					Trace( "SerializationTarget::DetermineCanDeserialize({0}, {1}) -> {2}: Default", targetType, kind, allowDefault );
+					diag.DetectedAsDeserializable(
+						new
+						{
+							targetType,
+							constructorKind = "Default",
+							allowsDefault = allowDefault
+						}
+					);
 					return allowDefault;
 				}
 				default:
 				{
-					Contract.Assert( kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous, "kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous : " + kind );
+					Debug.Assert(kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous, "kind == ConstructorKind.None || kind == ConstructorKind.Ambiguous : " + kind);
 					return false;
 				}
 			}
 		}
 
-		private static MemberInfo[] GetDistinctMembers( Type type )
+		private static MemberInfo[] GetDistinctMembers(Type type)
 		{
 			var distinctMembers = new List<MemberInfo>();
 			var returningMemberNamesSet = new HashSet<string>();
-			while ( type != typeof( object ) && type != null )
+			while (type != typeof(object) && type != null)
 			{
 				var members =
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
 					type.FindMembers(
 						MemberTypes.Field | MemberTypes.Property,
 						BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly,
 						null,
 						null
 					);
-#else
-					type.GetTypeInfo().DeclaredFields.Where( f => !f.IsStatic ).OfType<MemberInfo>()
-						.Concat( type.GetTypeInfo().DeclaredProperties.Where( p => p.GetMethod != null && !p.GetMethod.IsStatic ) );
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
-				foreach ( var memberInfo in members )
+				foreach (var memberInfo in members)
 				{
-					if ( returningMemberNamesSet.Add( memberInfo.Name ) ) //HashSet returns true is new key was added
+					if (returningMemberNamesSet.Add(memberInfo.Name)) //HashSet returns true is new key was added
 					{
-						distinctMembers.Add( memberInfo );
+						distinctMembers.Add(memberInfo);
 					}
 				}
 
@@ -367,124 +338,77 @@ private static MemberInfo[] GetDistinctMembers( Type type )
 			return distinctMembers.ToArray();
 		}
 
-		private static IEnumerable<SerializingMember> GetTargetMembers( Type type )
+		private static IEnumerable<SerializingMember> GetTargetMembers(Type type, SerializerGenerationOptions options)
 		{
-			Contract.Assert( type != null, "type != null" );
+			Debug.Assert(type != null, "type != null");
 
-			var members = GetDistinctMembers( type );
-			var filtered = members.Where( item =>
-#if !UNITY
-				item.GetCustomAttributesData().Any( a => a.GetAttributeType().FullName == MessagePackMemberAttributeTypeName )
-#else
-				item.GetCustomAttributes( typeof( MessagePackMemberAttribute ), true ).Any()
-#endif // !UNITY
-			).ToArray();
+			var members = GetDistinctMembers(type);
+			var filtered =
+				members.Where(item =>
+					item.GetCustomAttributesData().Any(a => a.GetAttributeType().FullName == MessagePackMemberAttributeTypeName)
+				).ToArray();
 
-			if ( filtered.Length > 0 )
+			if (filtered.Length > 0)
 			{
-				return GetAnnotatedMembersWithDuplicationDetection( type, filtered );
+				return GetAnnotatedMembersWithDuplicationDetection(type, filtered);
 			}
 
-			if (
-#if !UNITY
-				type.GetCustomAttributesData().Any( attr =>
-					attr.GetAttributeType().FullName == "System.Runtime.Serialization.DataContractAttribute" )
-#else
-				type.GetCustomAttributes( true ).Any( attr =>
-					attr.GetType().FullName == "System.Runtime.Serialization.DataContractAttribute" ) 
-#endif // !UNITY
-			)
+			var compatibleMembers = GetCompatibleMembers(type.GetCustomAttributesData(), members, options).ToArray();
+			if (compatibleMembers.Any())
 			{
-				return GetSystemRuntimeSerializationCompatibleMembers( members );
+				return compatibleMembers;
 			}
 
-			return GetPublicUnpreventedMembers( members );
+			return GetPublicUnpreventedMembers(members, options);
 		}
 
-		private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplicationDetection( Type type, MemberInfo[] filtered )
+		private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplicationDetection(Type type, MemberInfo[] filtered)
 		{
 			var duplicated =
 				filtered.FirstOrDefault(
-#if !UNITY
-					member => member.GetCustomAttributesData().Any( a => a.GetAttributeType().FullName == MessagePackIgnoreAttributeTypeName )
-#else
-					member => member.GetCustomAttributes( typeof( MessagePackIgnoreAttribute ), true ).Any()
-#endif // !UNITY
+					member => member.GetCustomAttributesData().Any(a => a.GetAttributeType().FullName == MessagePackIgnoreAttributeTypeName)
 				);
 
-			if ( duplicated != null )
+			if (duplicated != null)
 			{
-				throw new SerializationException(
-					String.Format(
-						CultureInfo.CurrentCulture,
-						"A member '{0}' of type '{1}' is marked with both MessagePackMemberAttribute and MessagePackIgnoreAttribute.",
-						duplicated.Name,
-						type
-					)
-				);
+				Throw.MemberIsMarkedWithMemberAndIgnoreAttribute(type, duplicated.Name);
 			}
 
 			return
 				filtered.Select(
 					member =>
 					{
-#if !UNITY
-						var attribute = member.GetCustomAttributesData().Single( a => a.GetAttributeType().FullName == MessagePackMemberAttributeTypeName );
+						var attribute = member.GetCustomAttributesData().Single(a => a.GetAttributeType().FullName == MessagePackMemberAttributeTypeName);
 						return
 							new SerializingMember(
 								member,
 								new DataMemberContract(
 									member,
-									( string )GetAttributeProperty( MessagePackMemberAttributeTypeName, attribute, "Name" ),
-#if !SILVERLIGHT
-									( NilImplication )( ( int? )GetAttributeProperty( MessagePackMemberAttributeTypeName, attribute, "NilImplication" ) ).GetValueOrDefault(),
-									( int? )GetAttributeArgument( MessagePackMemberAttributeTypeName, attribute, 0 )
-#else
-									( NilImplication )GetAttributeProperty( MessagePackMemberAttributeTypeName, attribute, "NilImplication" ),
-									( int? )GetAttributeProperty( MessagePackMemberAttributeTypeName, attribute, "Id" )
-#endif // !SILVERLIGHT
-								)
-							);
-#else
-						var attribute = member.GetCustomAttributes( typeof( MessagePackMemberAttribute ), true ).Single() as MessagePackMemberAttribute;
-						return 
-							new SerializingMember(
-								member,
-								new DataMemberContract(
-									member,
-									attribute.Name,
-									attribute.NilImplication,
-									attribute.Id
+									(string?)GetAttributeProperty(MessagePackMemberAttributeTypeName, attribute, "Name"),
+									(NilImplication)((int?)GetAttributeProperty(MessagePackMemberAttributeTypeName, attribute, "NilImplication")).GetValueOrDefault(),
+									(int?)GetAttributeArgument(MessagePackMemberAttributeTypeName, attribute, 0)
 								)
 							);
-#endif // !UNITY
 					}
 				);
 		}
 
-#if !UNITY
-#if !SILVERLIGHT
-		private static object GetAttributeArgument( string attributeName, CustomAttributeData attribute, int index )
+		private static object? GetAttributeArgument(string attributeName, CustomAttributeData attribute, int index)
 		{
 			var arguments = attribute.GetConstructorArguments();
-			if ( arguments.Count < index )
+			if (arguments.Count < index)
 			{
 				// Use default.
 				return null;
 			}
 
-			return arguments[ index ].Value;
+			return arguments[index].Value;
 		}
-#endif // !SILVERLIGHT
 
-#if !SILVERLIGHT
-		private static object GetAttributeProperty( string attributeName, CustomAttributeData attribute, string propertyName )
-#else
-		private static object GetAttributeProperty( string attributeName, Attribute attribute, string propertyName )
-#endif // !SILVERLIGHT
+		private static object? GetAttributeProperty(string attributeName, CustomAttributeData attribute, string propertyName)
 		{
-			var property = attribute.GetNamedArguments().SingleOrDefault( a => a.GetMemberName() == propertyName );
-			if ( property.GetMemberName() == null )
+			var property = attribute.GetNamedArguments().SingleOrDefault(a => a.GetMemberName() == propertyName);
+			if (property.GetMemberName() == null)
 			{
 				// Use default.
 				return null;
@@ -492,98 +416,63 @@ private static object GetAttributeProperty( string attributeName, Attribute attr
 
 			return property.GetTypedValue().Value;
 		}
-#endif // !UNITY
 
-		private static IEnumerable<SerializingMember> GetSystemRuntimeSerializationCompatibleMembers( MemberInfo[] members )
+		private static MessagePackMemberAttributeData? ProvideDefaultMessagePackMemberAttributeCompatibility(
+			IEnumerable<CustomAttributeData> typeAttributes,
+			IEnumerable<CustomAttributeData> memberAttributes
+		)
 		{
-			return
-				members.Select(
-					item =>
-						new
-						{
-							member = item,
-							data =
-#if !UNITY
-								item.GetCustomAttributesData()
-								.FirstOrDefault(
-									data => data.GetAttributeType().FullName == "System.Runtime.Serialization.DataMemberAttribute"
-								)
-#else
-								item.GetCustomAttributes( true )
-								.FirstOrDefault(
-									data => data.GetType().FullName == "System.Runtime.Serialization.DataMemberAttribute"
-								)
-#endif // !UNITY
-						}
-					).Where( item => item.data != null )
-					.Select(
-						item =>
-						{
-#if !UNITY
-							var name =
-								item.data.GetNamedArguments()
-								.Where( arg => arg.GetMemberName() == "Name" )
-								.Select( arg => ( string )arg.GetTypedValue().Value )
-								.FirstOrDefault();
-							var id =
-								item.data.GetNamedArguments()
-								.Where( arg => arg.GetMemberName() == "Order" )
-								.Select( arg => ( int? )arg.GetTypedValue().Value )
-								.FirstOrDefault();
-							if ( id == -1 )
-							{
-								id = null;
-							}
-
-							return
-								new SerializingMember(
-									item.member,
-									new DataMemberContract( item.member, name, NilImplication.MemberDefault, id )
-								);
-#else
-							var nameProperty = item.data.GetType().GetProperty( "Name" );
-							var orderProperty = item.data.GetType().GetProperty( "Order" );
-							
-							if ( nameProperty == null || !nameProperty.CanRead || nameProperty.GetGetMethod().GetParameters().Length > 0 )
-							{
-								throw new SerializationException(
-									String.Format(
-										CultureInfo.CurrentCulture,
-										"Failed to get Name property from {0} type.",
-										item.data.GetType().AssemblyQualifiedName
-									)
-								);
-							} 
-
-							if( orderProperty == null || !orderProperty.CanRead || orderProperty.GetGetMethod().GetParameters().Length > 0 )
-							{
-								throw new SerializationException(
-									String.Format(
-										CultureInfo.CurrentCulture,
-										"Failed to get Order property from {0} type.",
-										item.data.GetType().AssemblyQualifiedName
-									)
-								);
-							}
-
-							var name = ( string )nameProperty.GetValue( item.data, null );
-							var id = ( int? )orderProperty.GetValue( item.data, null );
-							if ( id == -1 )
-							{
-								id = null;
-							}
-
-							return
-								new SerializingMember(
-									item.member,
-									new DataMemberContract( item.member, name, NilImplication.MemberDefault, id )
-								);							
-#endif // !UNITY
-						}
-					);
+			if (!typeAttributes.Any(a => a.GetAttributeType().FullName == "System.Runtime.Serialization.DataContractAttribute"))
+			{
+				return null;
+			}
+
+			var dataMemberAttribute =
+				memberAttributes
+				.FirstOrDefault(a =>
+					a.GetAttributeType()
+					.FullName == "System.Runtime.Serialization.DataMemberAttribute"
+				);
+			if (dataMemberAttribute == null)
+			{
+				return null;
+			}
+
+			var name = default(string?);
+			var order = default(int?);
+			foreach(var namedArgument in dataMemberAttribute.GetNamedArguments())
+			{
+				var memberName = namedArgument.GetMemberName();
+				if (memberName == "Name")
+				{
+					name = (string?)namedArgument.GetTypedValue().Value;
+				}
+				else if(memberName == "Order")
+				{
+					order = (int?)namedArgument.GetTypedValue().Value;
+				}
+			}
+
+			return new MessagePackMemberAttributeData(order < 0 ? null : order, name);
 		}
 
-		private static IEnumerable<SerializingMember> GetPublicUnpreventedMembers( MemberInfo[] members )
+		private static IEnumerable<SerializingMember> GetCompatibleMembers(IEnumerable<CustomAttributeData> typeAttributes, MemberInfo[] members, SerializerGenerationOptions options)
+			=> members.Select(m => 
+				(
+					Member: m,
+					Attribute: (options.MessagePackMemberAttributeCompatibilityProvider ?? ProvideDefaultMessagePackMemberAttributeCompatibility)
+								.Invoke(typeAttributes, m.GetCustomAttributesData())
+				)
+			).Where(x => x.Attribute != null)
+			.Select(x =>
+				new SerializingMember(
+					x.Member,
+					// TODO: NilImplication
+					new DataMemberContract(x.Member, x.Attribute.GetValueOrDefault().Name, NilImplication.MemberDefault, x.Attribute.GetValueOrDefault().Id)
+				)
+			);
+
+		private static IEnumerable<SerializingMember> GetPublicUnpreventedMembers(MemberInfo[] members, SerializerGenerationOptions options)
 		{
 			return members.Where(
 				member =>
@@ -591,50 +480,50 @@ private static IEnumerable<SerializingMember> GetPublicUnpreventedMembers( Membe
 					&& !member
 #if !UNITY
 						.GetCustomAttributesData()
-						.Select( data => data.GetAttributeType().FullName )
+						.Select(data => data.GetAttributeType().FullName!)
 #else
 						.GetCustomAttributes( true )
-						.Select( data => data.GetType().FullName )
+						.Select(data => data.GetType().FullName)
 #endif // !UNITY
-						.Any( attr =>
-							attr == "MsgPack.Serialization.MessagePackIgnoreAttribute"
-							|| attr == "System.Runtime.Serialization.IgnoreDataMemberAttribute"
-						)
-					&& !IsNonSerializedField( member )
-				).Select( member => new SerializingMember( member, new DataMemberContract( member ) ) );
+						.Any(t => options.IgnoreAttributeTypeNames.Contains(t))
+					&& !IsNonSerializedField(member)
+				).Select(member => new SerializingMember(member, new DataMemberContract(member)));
 		}
 
-		private static bool IsNonSerializedField( MemberInfo member )
+		private static bool IsNonSerializedField(MemberInfo member)
 		{
 			var asField = member as FieldInfo;
-			if ( asField == null )
+			if (asField == null)
 			{
 				return false;
 			}
 
-			return ( asField.Attributes & FieldAttributes.NotSerialized ) != 0;
+			return (asField.Attributes & FieldAttributes.NotSerialized) != 0;
 		}
 
-		private static ConstructorInfo FindDeserializationConstructor( SerializationContext context, Type targetType, out ConstructorKind constructorKind )
+		private static ConstructorInfo? FindDeserializationConstructor(DiagnosticSource diag, SerializerGenerationOptions options, Type targetType, out ConstructorKind constructorKind)
 		{
 			var constructors = targetType.GetConstructors().ToArray();
 
-			if ( constructors.Length == 0 )
+			if (constructors.Length == 0)
 			{
-				if ( context.CompatibilityOptions.AllowAsymmetricSerializer )
+				if (options.AllowsAsymmetricSerializer)
 				{
 					constructorKind = ConstructorKind.None;
 					return null;
 				}
 				else
 				{
-					throw NewTypeCannotBeSerializedException( targetType );
+					Throw.TypeCannotBeSerializedBecauseNoMembersAndNoParameterizedPublicConstructors(targetType);
+					// never
+					constructorKind = default;
+					return default;
 				}
 			}
 
 			// The marked construtor is always preferred.
-			var markedConstructors = FindExplicitDeserializationConstructors( constructors );
-			switch ( markedConstructors.Count )
+			var markedConstructors = FindExplicitDeserializationConstructors(constructors);
+			switch (markedConstructors.Count)
 			{
 				case 0:
 				{
@@ -644,126 +533,114 @@ private static ConstructorInfo FindDeserializationConstructor( SerializationCont
 				{
 					// OK use it for deserialization.
 					constructorKind = ConstructorKind.Marked;
-					return markedConstructors[ 0 ];
+					return markedConstructors[0];
 				}
 				default:
 				{
-					throw new SerializationException(
-						String.Format(
-							CultureInfo.CurrentCulture,
-							"There are multiple constructors marked with MessagePackDeserializationConstrutorAttribute in type '{0}'.",
-							targetType
-						)
-					);
+					Throw.TypeCannotBeSerializedBecauseThereAreMultipleMessagePackDeserializationConstrutorAttribute(targetType);
+					// never
+					constructorKind = default;
+					return default;
 				}
 			}
 
 			// A constructor which has most parameters will be used.
 			var mostRichConstructors =
-				constructors.GroupBy( ctor => ctor.GetParameters().Length ).OrderByDescending( g => g.Key ).First().ToArray();
-#if DEBUG
-			Trace( "SerializationTarget::FindDeserializationConstructor.MostRich({0}) -> {1}", targetType, String.Join( ";", mostRichConstructors.Select( x => x.ToString() ).ToArray() ) );
-#endif // DEBUG
-			switch ( mostRichConstructors.Length )
+				constructors.GroupBy(ctor => ctor.GetParameters().Length).OrderByDescending(g => g.Key).First().ToArray();
+
+			diag.DeserializationConstructorFound(
+				new
+				{
+					targetType = targetType,
+					constructors = mostRichConstructors.Select(x => x.ToString()).ToArray()
+				}
+			);
+
+			switch (mostRichConstructors.Length)
 			{
 				case 1:
 				{
-					if ( mostRichConstructors[ 0 ].GetParameters().Length == 0 )
+					if (mostRichConstructors[0].GetParameters().Length == 0)
 					{
-						if ( context.CompatibilityOptions.AllowAsymmetricSerializer )
+						if (options.AllowsAsymmetricSerializer)
 						{
 							constructorKind = ConstructorKind.Default;
-							return mostRichConstructors[ 0 ];
+							return mostRichConstructors[0];
 						}
 						else
 						{
-							throw NewTypeCannotBeSerializedException( targetType );
+							Throw.TypeCannotBeSerializedBecauseNoMembersAndNoParameterizedPublicConstructors(targetType);
+							// never
+							constructorKind = default;
+							return default;
 						}
 					}
 
 					// OK try use it but it may not handle deserialization correctly.
 					constructorKind = ConstructorKind.Parameterful;
-					return mostRichConstructors[ 0 ];
+					return mostRichConstructors[0];
 				}
 				default:
 				{
-					if ( context.CompatibilityOptions.AllowAsymmetricSerializer )
+					if (options.AllowsAsymmetricSerializer)
 					{
 						constructorKind = ConstructorKind.Ambiguous;
 						return null;
 					}
 					else
 					{
-						throw new SerializationException(
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot serialize type '{0}' because it does not have any serializable fields nor properties, and serializer generator failed to determine constructor to deserialize among({1}).",
-								targetType,
-								String.Join( ", ", mostRichConstructors.Select( ctor => ctor.ToString() ).ToArray() )
-							)
-						);
+						Throw.TypeCannotBeSerializedBecauseNoMembersAndAmbigiousConstructors(targetType, mostRichConstructors);
+						// never
+						constructorKind = default;
+						return default;
 					}
 				}
 			}
 		}
 
-		private static IList<ConstructorInfo> FindExplicitDeserializationConstructors( IEnumerable<ConstructorInfo> construtors )
+		private static IList<ConstructorInfo> FindExplicitDeserializationConstructors(IEnumerable<ConstructorInfo> construtors)
 		{
 			return
 				construtors
-				.Where( ctor =>
+				.Where(ctor =>
 #if !UNITY
-					ctor.GetCustomAttributesData().Any( a =>
-						a.GetAttributeType().FullName
+					ctor.GetCustomAttributesData().Any(a =>
+					   a.GetAttributeType().FullName
 #else
 					ctor.GetCustomAttributes( true ).Any( a =>
 						a.GetType().FullName
 #endif // !UNITY
 						== MessagePackDeserializationConstructorAttributeTypeName
-					)
+				   )
 				).ToArray();
 		}
 
-		private static SerializationException NewTypeCannotBeSerializedException( Type targetType )
-		{
-			return
-				new SerializationException(
-					String.Format(
-						CultureInfo.CurrentCulture,
-						"Cannot serialize type '{0}' because it does not have any serializable fields nor properties, and it does not have any public constructors with parameters.",
-						targetType
-					)
-				);
-		}
-
 
-		private static bool CheckTargetEligibility( SerializationContext context, MemberInfo member )
+		private static bool CheckTargetEligibility(SerializerGenerationOptions options, MemberInfo member)
 		{
-			var asProperty = member as PropertyInfo;
-			var asField = member as FieldInfo;
 			Type returnType;
 
-			if ( asProperty != null )
+			if (member is PropertyInfo asProperty)
 			{
-				if ( asProperty.GetIndexParameters().Length > 0 )
+				if (asProperty.GetIndexParameters().Length > 0)
 				{
 					// Indexer cannot be target except the type itself implements IDictionary or IDictionary<TKey,TValue>
 					return false;
 				}
 
 #if !NETSTANDARD1_1 && !NETSTANDARD1_3
-				var setter = asProperty.GetSetMethod( true );
+				var setter = asProperty.GetSetMethod(true);
 #else
 				var setter = asProperty.SetMethod;
 #endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
-				if ( setter != null )
+				if (setter != null)
 				{
-					if ( setter.GetIsPublic() )
+					if (setter.GetIsPublic())
 					{
 						return true;
 					}
 
-					if ( !context.SerializerOptions.DisablePrivilegedAccess )
+					if (!options.DisablesPrivilegedAccess)
 					{
 						// Can deserialize non-public setter if privileged.
 						return true;
@@ -772,9 +649,9 @@ private static bool CheckTargetEligibility( SerializationContext context, Member
 
 				returnType = asProperty.PropertyType;
 			}
-			else if ( asField != null )
+			else if (member is FieldInfo asField)
 			{
-				if ( !asField.IsInitOnly )
+				if (!asField.IsInitOnly)
 				{
 					return true;
 				}
@@ -783,15 +660,12 @@ private static bool CheckTargetEligibility( SerializationContext context, Member
 			}
 			else
 			{
-#if DEBUG
-				Contract.Assert( false, "Unknown type member " + member );
-#endif // DEBUG
-				// ReSharper disable once HeuristicUnreachableCode
+				Debug.Fail($"Unknown type member '{member}'");
 				return true;
 			}
 
-			var traits = returnType.GetCollectionTraits( CollectionTraitOptions.WithAddMethod, allowNonCollectionEnumerableTypes: false );
-			switch ( traits.CollectionType )
+			var traits = returnType.GetCollectionTraits(CollectionTraitOptions.WithAddMethod, allowNonCollectionEnumerableTypes: false);
+			switch (traits.CollectionType)
 			{
 				case CollectionKind.Array:
 				case CollectionKind.Map:
@@ -805,27 +679,25 @@ private static bool CheckTargetEligibility( SerializationContext context, Member
 			}
 		}
 
-		private static IList<SerializingMember> ComplementMembers( IList<SerializingMember> candidates, SerializationContext context, Type targetType )
+		private static IReadOnlyList<SerializingMember> ComplementMembers(IReadOnlyList<SerializingMember> candidates, SerializerGenerationOptions options, Type targetType)
 		{
-			if ( candidates.Count == 0 )
+			if (candidates.Count == 0)
 			{
 				return candidates;
 			}
 
-			if ( candidates[ 0 ].Contract.Id < 0 )
+			if (candidates[0].Contract.Id < 0)
 			{
 				return candidates;
 			}
 
-			if ( context.CompatibilityOptions.OneBoundDataMemberOrder && candidates[ 0 ].Contract.Id == 0 )
+			if (options.OneBoundDataMemberOrder && candidates[0].Contract.Id == 0)
 			{
-				throw new NotSupportedException(
-					"Cannot specify order value 0 on DataMemberAttribute when SerializationContext.CompatibilityOptions.OneBoundDataMemberOrder is set to true."
-				);
+				Throw.DataMemberAttributeCannotBeZeroWhenOneBoundDataMemberOrderIsTrue(targetType, candidates[0].MemberName);
 			}
 
 #if !UNITY
-			var maxId = candidates.Max( item => item.Contract.Id );
+			var maxId = candidates.Max(item => item.Contract.Id);
 #else
 			int maxId = -1;
 			foreach ( var id in candidates.Select( item => item.Contract.Id ) )
@@ -833,148 +705,121 @@ private static IList<SerializingMember> ComplementMembers( IList<SerializingMemb
 				maxId = Math.Max( id, maxId );
 			}
 #endif
-			var result = new List<SerializingMember>( maxId + 1 );
-			for ( int source = 0, destination = context.CompatibilityOptions.OneBoundDataMemberOrder ? 1 : 0;
+			var result = new List<SerializingMember>(maxId + 1);
+			for (int source = 0, destination = options.OneBoundDataMemberOrder ? 1 : 0;
 				source < candidates.Count;
-				source++, destination++ )
+				source++, destination++)
 			{
-#if DEBUG
-				Contract.Assert( candidates[ source ].Contract.Id >= 0, "candidates[ source ].Contract.Id >= 0" );
-#endif // DEBUG
+				Debug.Assert(candidates[source].Contract.Id >= 0, $"candidates[source].Contract.Id ({candidates[source].Contract.Id}) >= 0");
 
-				if ( candidates[ source ].Contract.Id < destination )
+				if (candidates[source].Contract.Id < destination)
 				{
-					throw new SerializationException(
-						String.Format(
-							CultureInfo.CurrentCulture,
-							"The member ID '{0}' is duplicated in the '{1}' elementType.",
-							candidates[ source ].Contract.Id,
-							targetType
-						)
-					);
+					Throw.MemberIdIsDuplicated(candidates[source].Contract.Id, targetType);
 				}
 
-				while ( candidates[ source ].Contract.Id > destination )
+				while (candidates[source].Contract.Id > destination)
 				{
-					result.Add( new SerializingMember() );
+					result.Add(new SerializingMember());
 					destination++;
 				}
 
-				result.Add( candidates[ source ] );
+				result.Add(candidates[source]);
 			}
 
-			VerifyNilImplication( targetType, result );
-			VerifyKeyUniqueness( result );
+			VerifyNilImplication(targetType, result);
+			VerifyKeyUniqueness(result);
 			return result;
 		}
 
-		private static void VerifyNilImplication( Type type, IEnumerable<SerializingMember> entries )
+		private static void VerifyNilImplication(Type type, IEnumerable<SerializingMember> entries)
 		{
-			foreach ( var serializingMember in entries )
+			foreach (var serializingMember in entries)
 			{
-				if ( serializingMember.Contract.NilImplication == NilImplication.Null )
+				Debug.Assert(serializingMember.Member != null, "VerifyNilImplication is called for Tuple.");
+
+				if (serializingMember.Contract.NilImplication == NilImplication.Null)
 				{
 					var itemType = serializingMember.Member.GetMemberValueType();
 
-					if ( itemType != typeof( MessagePackObject )
-						&& itemType.GetIsValueType()
-						&& Nullable.GetUnderlyingType( itemType ) == null )
+					if (!itemType.IsDefined(typeof(MessagePackNullableAttribute))
+						&& !itemType.IsNullableType())
 					{
-						SerializationExceptions.ThrowValueTypeCannotBeNull( serializingMember.Member.ToString(), itemType, type );
+						Throw.ValueTypeCannotBeNull(serializingMember.Member.ToString(), itemType, type);
 					}
 
 					bool isReadOnly;
-					FieldInfo asField;
-					PropertyInfo asProperty;
-					if ( ( asField = serializingMember.Member as FieldInfo ) != null )
+					if (serializingMember.Member is FieldInfo asField)
 					{
 						isReadOnly = asField.IsInitOnly;
 					}
 					else
 					{
-						asProperty = serializingMember.Member as PropertyInfo;
-#if DEBUG
-						Contract.Assert( asProperty != null, serializingMember.Member.ToString() );
-#endif // DEBUG
+						var asProperty = serializingMember.Member as PropertyInfo;
+						Debug.Assert(asProperty != null, serializingMember.Member.ToString());
 						isReadOnly = asProperty.GetSetMethod() == null;
 					}
 
-					if ( isReadOnly )
+					if (isReadOnly)
 					{
-						SerializationExceptions.ThrowNullIsProhibited( serializingMember.Member.ToString() );
+						Throw.NullIsProhibitedForReadOnlyMember(serializingMember.Member.ToString());
 					}
 				}
 			}
 		}
 
-		private static void VerifyKeyUniqueness( IList<SerializingMember> result )
+		private static void VerifyKeyUniqueness(IList<SerializingMember> result)
 		{
 			var duplicated = new Dictionary<string, List<MemberInfo>>();
 			var existents = new Dictionary<string, SerializingMember>();
-			foreach ( var member in result )
+			foreach (var member in result)
 			{
-				if ( member.Contract.Name == null )
+				if (member.Contract.Name == null)
 				{
 					continue;
 				}
 
+				Debug.Assert(member.Member != null, "VerifyKeyUniqueness is called for Tuple.");
+
 				try
 				{
-					existents.Add( member.Contract.Name, member );
+					existents.Add(member.Contract.Name, member);
 				}
-				catch ( ArgumentException )
+				catch (ArgumentException)
 				{
-					List<MemberInfo> list;
-					if ( duplicated.TryGetValue( member.Contract.Name, out list ) )
+					if (duplicated.TryGetValue(member.Contract.Name, out var list))
 					{
-						list.Add( member.Member );
+						list.Add(member.Member);
 					}
 					else
 					{
-						duplicated.Add( member.Contract.Name, new List<MemberInfo> { existents[ member.Contract.Name ].Member, member.Member } );
+						duplicated.Add(member.Contract.Name, new List<MemberInfo> { existents[member.Contract.Name].Member!, member.Member });
 					}
 				}
 			}
 
-			if ( duplicated.Count > 0 )
+			if (duplicated.Count > 0)
 			{
-				throw new InvalidOperationException(
-					String.Format(
-						CultureInfo.CurrentCulture,
-						"Some member keys specified with custom attributes are duplicated. Details: {{{0}}}",
-						String.Join(
-							",",
-							duplicated.Select(
-								kv => String.Format(
-									CultureInfo.CurrentCulture,
-									"\"{0}\":[{1}]",
-									kv.Key,
-									String.Join( ",", kv.Value.Select( m => String.Format( CultureInfo.InvariantCulture, "{0}.{1}({2})", m.DeclaringType, m.Name, ( m is FieldInfo ) ? "Field" : "Property" ) ).ToArray() )
-								)
-							).ToArray()
-						)
-					)
-				);
+				Throw.DuplicatedAttributes(duplicated);
 			}
 		}
 
-		public static SerializationTarget CreateForCollection( ConstructorInfo collectionConstructor, bool canDeserialize )
-		{
-			return new SerializationTarget( EmptyMembers, collectionConstructor, EmptyStrings, canDeserialize );
-		}
+		public static SerializationTarget CreateForCollection(Type targetType, CollectionTraits traits, ConstructorInfo collectionConstructor, bool canDeserialize)
+			=> new SerializationTarget(targetType, traits, Array.Empty<SerializingMember>(), collectionConstructor, Array.Empty<string>(), canDeserialize);
 
-#if !NET35
-		public static SerializationTarget CreateForTuple( IList<Type> itemTypes )
-		{
-			return new SerializationTarget( itemTypes.Select( ( _, i ) => new SerializingMember( GetTupleItemNameFromIndex( i ) ) ).ToArray(), null, null, true );
-		}
+		public static SerializationTarget CreateForTuple(Type targetType)
+			=> new SerializationTarget(
+				targetType,
+				CollectionTraits.NotCollection,
+				TupleItems.GetTupleItemMembers(targetType).Select((m, i) => new SerializingMember(m, GetTupleItemNameFromIndex(i))).ToArray(),
+				constructor: null,
+				correspondentMemberNames: null,
+				canDeserialize: true
+			);
 
-		public static string GetTupleItemNameFromIndex( int i )
-		{
-			return "Item" + ( i + 1 ).ToString( "D", CultureInfo.InvariantCulture );
-		}
-#endif // !NET35
+		public static string GetTupleItemNameFromIndex(int i)
+			=> $"Item{i + 1:D}";
 
+#warning TODO: REMOVE_CODEGEN
 #if FEATURE_CODEGEN
 		public static bool BuiltInSerializerExists( ISerializerGeneratorConfiguration configuration, Type type, CollectionTraits traits )
 		{
@@ -988,25 +833,17 @@ private sealed class MemberConstructorParameterEqualityComparer : EqualityCompar
 
 			private MemberConstructorParameterEqualityComparer() { }
 
-			public override bool Equals( KeyValuePair<string, Type> x, KeyValuePair<string, Type> y )
+			public override bool Equals(KeyValuePair<string, Type> x, KeyValuePair<string, Type> y)
 			{
-				return String.Equals( x.Key, y.Key, StringComparison.OrdinalIgnoreCase ) && x.Value == y.Value;
+				return String.Equals(x.Key, y.Key, StringComparison.OrdinalIgnoreCase) && x.Value == y.Value;
 			}
 
-			public override int GetHashCode( KeyValuePair<string, Type> obj )
+			public override int GetHashCode(KeyValuePair<string, Type> obj)
 			{
-				return ( obj.Key == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode( obj.Key ) ) ^ ( obj.Value == null ? 0 : obj.Value.GetHashCode() );
+				return (obj.Key == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Key)) ^ (obj.Value == null ? 0 : obj.Value.GetHashCode());
 			}
 		}
 
-		[Conditional( "DEBUG" )]
-		private static void Trace( string format, params object[] args )
-		{
-#if !SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE
-			Tracer.Binding.TraceEvent( Tracer.EventType.Trace, Tracer.EventId.Trace, format, args );
-#endif // !SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE
-		}
-
 		private enum ConstructorKind
 		{
 			None = 0,
diff --git a/src/MsgPack/Serialization/SerializerCapabilities.cs b/src/MsgPack/Serialization/SerializerCapabilities.cs
index a6a941f2c..3b184dd1e 100644
--- a/src/MsgPack/Serialization/SerializerCapabilities.cs
+++ b/src/MsgPack/Serialization/SerializerCapabilities.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -36,19 +20,40 @@ public enum SerializerCapabilities
 		/// <summary>
 		///		Caller can call <c>Pack</c> and <c>PackTo</c> method safely.
 		///		If this flag is not set, the serializer may be deserialize only serializer.
+		///		(v2) This value is synonym of <see cref="Serialize"/>.
 		/// </summary>
 		PackTo = 0x1,
 
+		/// <summary>
+		///		Caller can call <c>Serialize</c> method safely.
+		///		If this flag is not set, the serializer may be deserialize only serializer.
+		/// </summary>
+		Serialize = 0x1,
+
 		/// <summary>
 		///		Caller can call <c>Unpack</c> and <c>UnpackFrom</c> method safely.
 		///		If this flag is not set, the serializer may be serialize only serializer.
+		///		(v2) This value is synonym of <see cref="Deserialize"/>.
 		/// </summary>
 		UnpackFrom = 0x10,
 
+		/// <summary>
+		///		Caller can call <c>Deserialize</c> method safely.
+		///		If this flag is not set, the serializer may be serialize only serializer.
+		/// </summary>
+		Deserialize = 0x10,
+
 		/// <summary>
 		///		Caller can call <c>UnpackTo</c> method safely.
 		///		If this flag is not set, the serializer should not be for mutable collection type.
+		///		(v2) This value is synonym of <see cref="DeserializeTo"/>.
+		/// </summary>
+		UnpackTo = 0x20,
+
+		/// <summary>
+		///		Caller can call <c>DeserializeTo</c> method safely.
+		///		If this flag is not set, the serializer should not be for mutable collection type.
 		/// </summary>
-		UnpackTo = 0x20
+		DeserializeTo = 0x20
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/SerializerOptions.cs b/src/MsgPack/Serialization/SerializerOptions.cs
index 156e36970..ce3e7c2eb 100644
--- a/src/MsgPack/Serialization/SerializerOptions.cs
+++ b/src/MsgPack/Serialization/SerializerOptions.cs
@@ -1,28 +1,9 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2012-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
+using System.ComponentModel;
 #if FEATURE_MPCONTRACT
 using Contract = MsgPack.MPContract;
 #else
@@ -34,7 +15,7 @@
 #endif // NETSTANDARD1_3 || NETSTANDARD2_0
 using System.Runtime.CompilerServices;
 using System.Threading;
-#if ( NETSTANDARD1_3 || NETSTANDARD2_0 ) && !WINDOWS_UWP
+#if (NETSTANDARD1_3 || NETSTANDARD2_0) && !WINDOWS_UWP
 using MsgPack.Serialization.EmittingSerializers;
 #endif // ( NETSTANDARD1_3 || NETSTANDARD2_0 ) && !WINDOWS_UWP
 
@@ -45,32 +26,6 @@ namespace MsgPack.Serialization
 	/// </summary>
 	public sealed class SerializerOptions
 	{
-#if UNITY || SILVERLIGHT
-		private int _emitterFlavor = ( int )EmitterFlavor.ReflectionBased;
-#else
-		private int _emitterFlavor = ( int )EmitterFlavor.FieldBased;
-#endif
-
-		/// <summary>
-		///		Gets or sets the <see cref="EmitterFlavor"/>.
-		/// </summary>
-		/// <value>
-		///		The <see cref="EmitterFlavor"/>
-		/// </value>
-		/// <remarks>
-		///		For testing purposes.
-		/// </remarks>
-#if UNITY && DEBUG
-		public
-#else
-		internal
-#endif
-		EmitterFlavor EmitterFlavor
-		{
-			get { return ( EmitterFlavor )Volatile.Read( ref this._emitterFlavor ); }
-			set { Volatile.Write( ref this._emitterFlavor, ( int )value ); }
-		}
-
 #if !UNITY
 
 		private int _generatorOption;
@@ -86,13 +41,13 @@ public SerializationMethodGeneratorOption GeneratorOption
 		{
 			get
 			{
-				Contract.Ensures( Enum.IsDefined( typeof( SerializationMethod ), Contract.Result<SerializationMethodGeneratorOption>() ) );
+				Contract.Ensures(Enum.IsDefined(typeof(SerializationMethod), Contract.Result<SerializationMethodGeneratorOption>()));
 
-				return ( SerializationMethodGeneratorOption )Volatile.Read( ref this._generatorOption );
+				return (SerializationMethodGeneratorOption)Volatile.Read(ref this._generatorOption);
 			}
 			set
 			{
-				switch ( value )
+				switch (value)
 				{
 					case SerializationMethodGeneratorOption.Fast:
 #if !SILVERLIGHT
@@ -106,13 +61,13 @@ public SerializationMethodGeneratorOption GeneratorOption
 					}
 					default:
 					{
-						throw new ArgumentOutOfRangeException( "value" );
+						throw new ArgumentOutOfRangeException("value");
 					}
 				}
 
 				Contract.EndContractBlock();
 
-				Volatile.Write( ref this._generatorOption, ( int )value );
+				Volatile.Write(ref this._generatorOption, (int)value);
 			}
 		}
 
@@ -150,10 +105,10 @@ public bool DisableRuntimeCodeGeneration
 
 		internal static readonly bool CanEmit = DetermineCanEmit();
 
-		[MethodImpl( MethodImplOptions.NoInlining )]
+		[MethodImpl(MethodImplOptions.NoInlining)]
 		private static bool DetermineCanEmit()
 		{
-#if ( NETSTANDARD1_3 || NETSTANDARD2_0 ) && !WINDOWS_UWP
+#if (NETSTANDARD1_3 || NETSTANDARD2_0) && !WINDOWS_UWP
 			try
 			{
 				return DetermineCanEmitCore();
@@ -170,7 +125,7 @@ private static bool DetermineCanEmit()
 #endif
 		}
 
-#if ( NETSTANDARD1_3 || NETSTANDARD2_0 ) && !WINDOWS_UWP
+#if (NETSTANDARD1_3 || NETSTANDARD2_0) && !WINDOWS_UWP
 
 		[MethodImpl( MethodImplOptions.NoInlining )]
 		private static bool DetermineCanEmitCore()
diff --git a/src/MsgPack/Serialization/SerializingMember.cs b/src/MsgPack/Serialization/SerializingMember.cs
index f6e77e838..912f10069 100644
--- a/src/MsgPack/Serialization/SerializingMember.cs
+++ b/src/MsgPack/Serialization/SerializingMember.cs
@@ -1,34 +1,9 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
-using System.Globalization;
-#if FEATURE_MPCONTRACT
-using MPContract = MsgPack.MPContract;
-#else
-using MPContract = System.Diagnostics.Contracts.Contract;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 using System.Reflection;
 
 namespace MsgPack.Serialization
@@ -36,105 +11,47 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Represents serializing member information.
 	/// </summary>
-#if !UNITY
-	internal struct SerializingMember
-#else
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	sealed class SerializingMember
-#endif // !UNITY
+	internal readonly struct SerializingMember
 	{
-		public readonly MemberInfo Member;
-		public readonly DataMemberContract Contract;
-		public readonly string MemberName;
+		public MemberInfo Member { get; }
+		public DataMemberContract Contract { get; }
+		public string MemberName { get; }
+		public Utf8String Utf8MemberName { get; }
 
-#if UNITY
-		public SerializingMember()
+		public SerializingMember(MemberInfo member, DataMemberContract contract)
 		{
-			this.Member = null;
-			this.Contract = new DataMemberContract ();
-		}
-#endif // UNITY
-
-		public SerializingMember( MemberInfo member, DataMemberContract contract )
-		{
-#if DEBUG
-			MPContract.Assert( member != null );
-#endif // DEBUG
 			this.Member = member;
 			this.Contract = contract;
 			// Use contract name for aliased map serialization.
-			this.MemberName = member == null ? null : contract.Name;
+			this.MemberName = contract.Name;
+			this.Utf8MemberName = new Utf8String(contract.Name);
 		}
 
-#if !NET35
-		// For Tuple
-		public SerializingMember( string name )
+		// for tuple
+		public SerializingMember(MemberInfo member, string name)
 		{
-#if DEBUG
-			MPContract.Assert( name.StartsWith( "Item" ), name + ".StartsWith(\"Item\")" );
-#endif // DEBUG
-			this.Member = null;
-			this.Contract = default ( DataMemberContract );
+			this.Member = member;
+			this.Contract = default;
+			// Use contract name for aliased map serialization.
 			this.MemberName = name;
+			this.Utf8MemberName = new Utf8String(name);
 		}
-#endif // !NET35
 
 		public EnumMemberSerializationMethod GetEnumMemberSerializationMethod()
-		{
-#if NETSTANDARD1_1 || NETSTANDARD1_3
-			var messagePackEnumMemberAttribute = 
-				this.Member.GetCustomAttribute<MessagePackEnumMemberAttribute>();
-			if ( messagePackEnumMemberAttribute != null)
-			{
-				return messagePackEnumMemberAttribute.SerializationMethod;
-#else
-			var messagePackEnumMemberAttributes =
-				this.Member.GetCustomAttributes( typeof( MessagePackEnumMemberAttribute ), true );
-			if ( messagePackEnumMemberAttributes.Length > 0 )
-			{
-				return
-					// ReSharper disable once PossibleNullReferenceException
-					( messagePackEnumMemberAttributes[ 0 ] as MessagePackEnumMemberAttribute ).SerializationMethod;
-#endif // NETSTANDARD1_1 || NETSTANDARD1_3
-			}
-
-			return EnumMemberSerializationMethod.Default;
-		}
+			=> this.Member.GetCustomAttribute<MessagePackEnumMemberAttribute>(inherit: true)?.SerializationMethod ?? EnumMemberSerializationMethod.Default;
 
 		public DateTimeMemberConversionMethod GetDateTimeMemberConversionMethod()
-		{
-#if NETSTANDARD1_1 || NETSTANDARD1_3
-			var messagePackDateTimeMemberAttribute = 
-				this.Member.GetCustomAttribute<MessagePackDateTimeMemberAttribute>();
-			if ( messagePackDateTimeMemberAttribute != null)
-			{
-				return messagePackDateTimeMemberAttribute.DateTimeConversionMethod;
-#else
-			var messagePackDateTimeMemberAttribute =
-				this.Member.GetCustomAttributes( typeof( MessagePackDateTimeMemberAttribute ), true );
-			if ( messagePackDateTimeMemberAttribute.Length > 0 )
-			{
-				return
-					// ReSharper disable once PossibleNullReferenceException
-					( messagePackDateTimeMemberAttribute[ 0 ] as MessagePackDateTimeMemberAttribute ).DateTimeConversionMethod;
-#endif // NETSTANDARD1_1 || NETSTANDARD1_3
-			}
-
-			return DateTimeMemberConversionMethod.Default;
-		}
+			=> this.Member.GetCustomAttribute<MessagePackDateTimeMemberAttribute>(inherit: true)?.DateTimeConversionMethod ?? DateTimeMemberConversionMethod.Default;
 
 		public override string ToString()
 		{
-			if ( this.MemberName == null )
+			if (this.MemberName == null)
 			{
+				// default instance.
 				return String.Empty;
 			}
 
-			return String.Format( CultureInfo.InvariantCulture, "{{\"Name\": \"{0}\", \"Id\": {1}, \"Member\": \"{2}\", \"NilImplication\": \"{3}\" }}", this.MemberName, this.Contract.Id, this.MemberName, this.Contract.NilImplication );
+			return $"{{\"Name\": \"{this.MemberName}\", \"Id\": {this.Contract.Id}, \"Member\": \"{this.Member}\", \"NilImplication\": \"{this.Contract.NilImplication}\" }}";
 		}
 	}
 }
diff --git a/src/MsgPack/TupleItems.cs b/src/MsgPack/TupleItems.cs
index 37963d470..3920a8dd1 100644
--- a/src/MsgPack/TupleItems.cs
+++ b/src/MsgPack/TupleItems.cs
@@ -1,36 +1,12 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2017 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
-
-#if !UNITY
 using System;
 using System.Collections.Generic;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 using System.Linq;
+using System.Reflection;
 
 namespace MsgPack
 {
@@ -47,29 +23,29 @@ internal static class TupleItems
 		///		The type list for nested tuples.
 		///		The order is from outer to inner.
 		/// </returns>
-		public static List<Type> CreateTupleTypeList( Type rootTupleType )
+		public static List<Type> CreateTupleTypeList(Type rootTupleType)
 		{
-			if ( !rootTupleType.GetIsGenericType() )
+			if (!rootTupleType.GetIsGenericType())
 			{
 				// arity 0 value tuple
-				return new List<Type>( 1 ) { rootTupleType };
+				return new List<Type>(1) { rootTupleType };
 			}
 
 			var assembly = rootTupleType.GetAssembly();
-			var baseName = rootTupleType.FullName.Remove( rootTupleType.FullName.IndexOf( '`' ) + 1 );
+			var baseName = rootTupleType.FullName!.Remove(rootTupleType.FullName.IndexOf('`') + 1);
 			var result = new List<Type>();
 			var tupleType = rootTupleType;
-			while ( true )
+			while (true)
 			{
-				result.Add( tupleType );
-				if ( !tupleType.GetIsGenericType() )
+				result.Add(tupleType);
+				if (!tupleType.GetIsGenericType())
 				{
 					// arity 0
 					break;
 				}
 
 				var itemTypes = tupleType.GetGenericArguments();
-				if ( itemTypes.Length < 8 )
+				if (itemTypes.Length < 8)
 				{
 					// leaf tuple
 					break;
@@ -81,45 +57,66 @@ public static List<Type> CreateTupleTypeList( Type rootTupleType )
 			return result;
 		}
 
-		public static IList<Type> GetTupleItemTypes( Type tupleType )
+		public static IReadOnlyList<MemberInfo> GetTupleItemMembers(Type tupleType)
+		{
+			Debug.Assert(IsTuple(tupleType), $"IsTuple({tupleType.AssemblyQualifiedName})");
+			var members = new List<MemberInfo>(tupleType.GetGenericArguments().Length);
+			GetTupleItemMembers(tupleType, members);
+			return members;
+		}
+
+		private static void GetTupleItemMembers(Type tupleType, IList<MemberInfo> result)
+		{
+			var properties = tupleType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+			var count = properties.Length == 8 ? 7 : properties.Length;
+			for (var i = 0; i < count; i++)
+			{
+				result.Add(properties[i]);
+			}
+
+			if (properties.Length == 8)
+			{
+				var rest = properties[7];
+				Debug.Assert(IsTuple(rest.PropertyType), $"IsTuple({rest.PropertyType.AssemblyQualifiedName})");
+				// Put nested tuple's item types recursively.
+				GetTupleItemMembers(rest.PropertyType, result);
+			}
+		}
+
+		public static IReadOnlyList<Type> GetTupleItemTypes(Type tupleType)
 		{
-#if DEBUG
-			Contract.Assert( IsTuple( tupleType ), "IsTuple( "+ tupleType.AssemblyQualifiedName + " )" );
-#endif // DEBUG
+			Debug.Assert(IsTuple(tupleType), $"IsTuple({tupleType.AssemblyQualifiedName})");
 			var arguments = tupleType.GetGenericArguments();
-			var itemTypes = new List<Type>( tupleType.GetGenericArguments().Length );
-			GetTupleItemTypes( arguments, itemTypes );
+			var itemTypes = new List<Type>(tupleType.GetGenericArguments().Length);
+			GetTupleItemTypes(arguments, itemTypes);
 			return itemTypes;
 		}
 
-		private static void GetTupleItemTypes( IList<Type> itemTypes, IList<Type> result )
+		private static void GetTupleItemTypes(IList<Type> itemTypes, IList<Type> result)
 		{
 			var count = itemTypes.Count == 8 ? 7 : itemTypes.Count;
-			for ( var i = 0; i < count; i++ )
+			for (var i = 0; i < count; i++)
 			{
-				result.Add( itemTypes[ i ] );
+				result.Add(itemTypes[i]);
 			}
 
-			if ( itemTypes.Count == 8 )
+			if (itemTypes.Count == 8)
 			{
-				var trest = itemTypes[ 7 ];
-#if DEBUG
-				Contract.Assert( IsTuple( trest ), "IsTuple( " + trest.AssemblyQualifiedName + " )" );
-#endif // DEBUG
+				var trest = itemTypes[7];
+				Debug.Assert(IsTuple(trest), $"IsTuple({trest.AssemblyQualifiedName})");
 				// Put nested tuple's item types recursively.
-				GetTupleItemTypes( trest.GetGenericArguments(), result );
+				GetTupleItemTypes(trest.GetGenericArguments(), result);
 			}
 		}
 
-		public static bool IsTuple( Type type )
+		public static bool IsTuple(Type type)
 		{
 			return
 				type.GetIsPublic()
-				&& ( ( type.FullName.StartsWith( "System.ValueTuple`", StringComparison.Ordinal ) && type.GetIsValueType() )
-					|| ( type.FullName.StartsWith( "System.Tuple`", StringComparison.Ordinal ) && !type.GetIsValueType() )
-					|| ( type.FullName == "System.ValueTuple" && type.GetIsValueType() )
+				&& ((type.FullName!.StartsWith("System.ValueTuple`", StringComparison.Ordinal) && type.GetIsValueType())
+					|| (type.FullName.StartsWith("System.Tuple`", StringComparison.Ordinal) && !type.GetIsValueType())
+					|| (type.FullName == "System.ValueTuple" && type.GetIsValueType())
 				);
 		}
 	}
 }
-#endif // !UNITY
diff --git a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
index ec0a34f72..78875f3b1 100644
--- a/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
+++ b/test/Benchmark/MessagePackCsharp/Benchmark/Serializers/MsgPackCliSerializer.cs
@@ -40,41 +40,41 @@ internal static class MsgPackCliSerializerRepository<T>
 {
 	public static readonly MsgPack.Serialization.MessagePackSerializer<T> V1 = SampleSerializer.SerializationContext.GetSerializer<T>();
 
-	public static readonly newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType> V2 = InitV2();
+	public static readonly newmpcli::MsgPack.Serialization.ObjectSerializer<T> V2 = InitV2();
 
-	public static readonly newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType> Json = InitJson();
+	public static readonly newmpcli::MsgPack.Serialization.ObjectSerializer<T> Json = InitJson();
 
-	private static newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType> InitV2()
+	private static newmpcli::MsgPack.Serialization.ObjectSerializer<T> InitV2()
 	{
 		if (typeof(MsgPack.Samples.SampleObject).IsAssignableFrom(typeof(T)))
 		{
-			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType>)(object)new MsgPack.Samples.SampleSerializer<newmpcli::MsgPack.Internal.MessagePackExtensionType>();
+			return (newmpcli::MsgPack.Serialization.ObjectSerializer<T>)(object)new MsgPack.Samples.SampleSerializer(new newmpcli::MsgPack.Serialization.ObjectSerializationContext());
 		}
 		else if (typeof(T) == typeof(int[]))
 		{
-			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType>)(object)new MsgPack.Samples.SampleInt32ArraySerializer<newmpcli::MsgPack.Internal.MessagePackExtensionType>();
+			return (newmpcli::MsgPack.Serialization.ObjectSerializer<T>)(object)new MsgPack.Samples.SampleInt32ArraySerializer(new newmpcli::MsgPack.Serialization.ObjectSerializationContext());
 		}
 		else if (typeof(T) == typeof(int))
 		{
-			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.MessagePackExtensionType>)(object)new MsgPack.Samples.SampleInt32Serializer<newmpcli::MsgPack.Internal.MessagePackExtensionType>();
+			return (newmpcli::MsgPack.Serialization.ObjectSerializer<T>)(object)new MsgPack.Samples.SampleInt32Serializer(new newmpcli::MsgPack.Serialization.ObjectSerializationContext());
 		}
 
 		throw new NotSupportedException($"No {typeof(T)} serializer.");
 	}
 
-	private static newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType> InitJson()
+	private static newmpcli::MsgPack.Serialization.ObjectSerializer<T> InitJson()
 	{
 		if (typeof(MsgPack.Samples.SampleObject).IsAssignableFrom(typeof(T)))
 		{
-			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType>)(object)new MsgPack.Samples.SampleSerializer<newmpcli::MsgPack.Internal.NullExtensionType>();
+			return (newmpcli::MsgPack.Serialization.ObjectSerializer<T>)(object)new MsgPack.Samples.SampleSerializer(new newmpcli::MsgPack.Serialization.ObjectSerializationContext());
 		}
 		else if (typeof(T) == typeof(int[]))
 		{
-			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType>)(object)new MsgPack.Samples.SampleInt32ArraySerializer<newmpcli::MsgPack.Internal.NullExtensionType>();
+			return (newmpcli::MsgPack.Serialization.ObjectSerializer<T>)(object)new MsgPack.Samples.SampleInt32ArraySerializer(new newmpcli::MsgPack.Serialization.ObjectSerializationContext());
 		}
 		else if (typeof(T) == typeof(int))
 		{
-			return (newmpcli::MsgPack.Serialization.Internal.IObjectSerializer<T, newmpcli::MsgPack.Internal.NullExtensionType>)(object)new MsgPack.Samples.SampleInt32Serializer<newmpcli::MsgPack.Internal.NullExtensionType>();
+			return (newmpcli::MsgPack.Serialization.ObjectSerializer<T>)(object)new MsgPack.Samples.SampleInt32Serializer(new newmpcli::MsgPack.Serialization.ObjectSerializationContext());
 		}
 
 		throw new NotSupportedException($"No {typeof(T)} serializer.");
@@ -91,7 +91,7 @@ public override T Deserialize<T>(object input)
 	{
 		var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>((byte[])input));
 		var context =
-			new newmpcli::MsgPack.Serialization.Internal.DeserializationOperationContext<newmpcli::MsgPack.Internal.MessagePackExtensionType>(
+			new newmpcli::MsgPack.Serialization.DeserializationOperationContext(
 				Decoder,
 				null,
 				CancellationToken.None
@@ -115,7 +115,7 @@ public override object Serialize<T>(T input)
 
 		var writer = t_writer;
 		var context =
-			new newmpcli::MsgPack.Serialization.Internal.SerializationOperationContext<newmpcli::MsgPack.Internal.MessagePackExtensionType>(
+			new newmpcli::MsgPack.Serialization.SerializationOperationContext(
 				Encoder,
 				null,
 				CancellationToken.None
@@ -136,7 +136,7 @@ public override T Deserialize<T>(object input)
 	{
 		var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>((byte[])input));
 		var context =
-			new newmpcli::MsgPack.Serialization.Internal.DeserializationOperationContext<newmpcli::MsgPack.Internal.NullExtensionType>(
+			new newmpcli::MsgPack.Serialization.DeserializationOperationContext(
 				Decoder,
 				null,
 				CancellationToken.None
@@ -160,7 +160,7 @@ public override object Serialize<T>(T input)
 
 		var writer = t_writer;
 		var context =
-			new newmpcli::MsgPack.Serialization.Internal.SerializationOperationContext<newmpcli::MsgPack.Internal.NullExtensionType>(
+			new newmpcli::MsgPack.Serialization.SerializationOperationContext(
 				Encoder,
 				null,
 				CancellationToken.None
diff --git a/test/Benchmark/_SampleObject.cs b/test/Benchmark/_SampleObject.cs
index 9451254c4..4675f9997 100644
--- a/test/Benchmark/_SampleObject.cs
+++ b/test/Benchmark/_SampleObject.cs
@@ -21,9 +21,9 @@
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using newmpcli::MsgPack.Serialization;
 using newmpcli::MsgPack.Internal;
 using newmpcli::MsgPack.Json;
-using newmpcli::MsgPack.Serialization.Internal;
 
 namespace MsgPack.Samples
 {
@@ -179,7 +179,11 @@ public class SampleObject
 	// Packer -> Packer.Create(new MemoryStream())
 	// Unpacker -> Unpacker.Create(new MemoryStream())???
 
-	internal static class SampleSerializer
+	// For PoC of MVP and reference for emit.
+	/// <summary>
+	///		Sample hand made serializer.
+	/// </summary>
+	public sealed class SampleSerializer : ObjectSerializer<SampleObject>
 	{
 		public static readonly MsgPack.Serialization.SerializationContext SerializationContext =
 #if USE_ARRAY
@@ -187,14 +191,10 @@ internal static class SampleSerializer
 #else
 			new Serialization.SerializationContext() { SerializationMethod = Serialization.SerializationMethod.Map };
 #endif
-	}
+		public SampleSerializer(ObjectSerializationContext ownedContext)
+			: base(ownedContext, SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize | SerializerCapabilities.DeserializeTo) { }
+
 
-	// For PoC of MVP and reference for emit.
-	/// <summary>
-	///		Sample hand made serializer.
-	/// </summary>
-	public sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleObject, TExtensionType>
-	{
 		private bool UseArray { get; set; }
 #if USE_ARRAY
 			= true;
@@ -215,7 +215,7 @@ public sealed class SampleSerializer<TExtensionType> : IObjectSerializer<SampleO
 #endif
 			}.Build();
 
-		public void Serialize(ref SerializationOperationContext<TExtensionType> context, SampleObject obj, IBufferWriter<byte> writer)
+		public sealed override void Serialize(ref SerializationOperationContext context, SampleObject obj, IBufferWriter<byte> writer)
 		{
 #if JSON
 			var encoder = new JsonEncoder(context.Encoder.Options as JsonEncoderOptions);
@@ -509,15 +509,6 @@ public void Serialize(ref SerializationOperationContext<TExtensionType> context,
 #endif // !USE_ARRAY
 		}
 
-		public async ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, SampleObject obj, Stream streamSink)
-		{
-			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
-			{
-				var serializationOperationContext = context.AsSerializationOperationContext();
-				this.Serialize(ref serializationOperationContext, obj, writer);
-			}
-		}
-
 		private static readonly MsgPackStringTrie<uint> DeserializationTrie = InitializeDeserializationTrie();
 		private static MsgPackStringTrie<uint> InitializeDeserializationTrie()
 		{
@@ -575,7 +566,7 @@ private static MsgPackStringTrie<uint> InitializeDeserializationTrie()
 			return trie;
 		}
 
-		public SampleObject Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> reader)
+		public sealed override SampleObject Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> reader)
 		{
 #warning TODO: Inlining to avoid allocation when null.
 			// WHEN T is reference type and it has a default contractor -> DeserializeToAsync
@@ -605,7 +596,7 @@ public SampleObject Deserialize(ref DeserializationOperationContext<TExtensionTy
 			// return obj;
 		}
 
-		public async ValueTask<SampleObject> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		public sealed override async ValueTask<SampleObject> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence streamSource)
 		{
 			var obj = new SampleObject();
 			// WHEN T is reference type and it has a default contractor -> DeserializeToAsync
@@ -637,7 +628,7 @@ public async ValueTask<SampleObject> DeserializeAsync(AsyncDeserializationOperat
 		private static void ThrowNotEnoughItems(long actual, int expected)
 			=> throw new MessageTypeException();
 
-		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> reader, in SampleObject obj)
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> reader, in SampleObject obj)
 		{
 			const int propertyCount =
 					0
@@ -1234,10 +1225,10 @@ private static void CheckNextItemExists(ref SequenceReader<byte> reader, ref Col
 			}
 		}
 
-		private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
+		private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out long itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
 		{
 			context.IncrementDepth();
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(ref reader, out itemsCount, out requestHint);
 			if (arrayOrMap.IsNone)
@@ -1262,161 +1253,163 @@ private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationConte
 				itemsCount = -1;
 			}
 
-			memory = memory.Slice(unchecked((int)reader.Consumed));
+			sequence = sequence.Slice(reader.Consumed);
 
 			return true;
 		}
 
-		private static bool TryDecodeArrayHeader(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long arrayLength, out int requestHint)
+		private static bool TryDecodeArrayHeader(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out long arrayLength, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			arrayLength = context.Decoder.DecodeArrayHeader(ref reader, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeMapHeader(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out long mapCount, out int requestHint)
+		private static bool TryDecodeMapHeader(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out long mapCount, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			mapCount = context.Decoder.DecodeMapHeader(ref reader, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfName(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string name, out int requestHint)
+		private static bool TryDecodeValueOfName(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out string name, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			name = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfAge(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out int age, out int requestHint)
+		private static bool TryDecodeValueOfAge(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out int age, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			age = context.Decoder.DecodeInt32(ref reader, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfIsActive(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out bool isActive, out int requestHint)
+		private static bool TryDecodeValueOfIsActive(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out bool isActive, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			isActive = context.Decoder.DecodeBoolean(ref reader, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeItemOfRoles(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string item, out int requestHint)
+		private static bool TryDecodeItemOfRoles(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out string item, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			item = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeKeyOfAttributes(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string key, out int requestHint)
+		private static bool TryDecodeKeyOfAttributes(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out string key, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			key = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeValueOfAttributes(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out string value, out int requestHint)
+		private static bool TryDecodeValueOfAttributes(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out string value, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			value = context.Decoder.DecodeString(ref reader, out requestHint, context.StringEncoding, context.CancellationToken)!; // <>NameEncoding ?? context.StringEncoding
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeArray(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		private static bool TryDecodeArray(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out CollectionItemIterator iterator, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			iterator = context.Decoder.DecodeArray(ref reader, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryDecodeMap(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, out CollectionItemIterator iterator, out int requestHint)
+		private static bool TryDecodeMap(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out CollectionItemIterator iterator, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			iterator = context.Decoder.DecodeMap(ref reader, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private static bool TryGetRawString(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, [NotNullWhen(true)] out byte[] key, out int requestHint)
+		private static bool TryGetRawString(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, [NotNullWhen(true)] out byte[] keyArray, out ReadOnlyMemory<byte> key, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 
 			ReadOnlySpan<byte> span;
 			if (!context.Decoder.GetRawString(ref reader, out span, out requestHint, context.CancellationToken))
 			{
-				key = default!;
+				keyArray = default!;
+				key = default;
 				return false;
 			}
 
-			key = context.ByteBufferPool.Rent(span.Length);
-			span.CopyTo(key);
+			keyArray = context.ByteBufferPool.Rent(span.Length);
+			span.CopyTo(keyArray);
+			key = keyArray.AsMemory(0, span.Length);
 			return true;
 		}
 
-		private static bool TryDrain(AsyncDeserializationOperationContext<TExtensionType> context, ref ReadOnlyMemory<byte> memory, long remaining, out int requestHint)
+		private static bool TryDrain(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, long remaining, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memory));
+			var reader = new SequenceReader<byte>(sequence);
 			context.Decoder.Drain(ref reader, context.CollectionContext, remaining, out requestHint);
 			if (requestHint == 0)
 			{
-				memory = memory.Slice(unchecked((int)reader.Consumed));
+				sequence = sequence.Slice(reader.Consumed);
 			}
 			return requestHint == 0;
 		}
 
-		private bool TryCheckNextItemExists(ref CollectionItemIterator propertyIterator, ReadOnlyMemory<byte> memory, out int requestHint)
+		private bool TryCheckNextItemExists(ref CollectionItemIterator propertyIterator, ReadOnlySequence<byte> sequence, out int requestHint)
 		{
-			if (propertyIterator.CollectionEnds(memory, out requestHint))
+			if (propertyIterator.CollectionEnds(sequence, out requestHint))
 			{
 				throw new MessageTypeException(); // use throws
 			}
@@ -1424,486 +1417,482 @@ private bool TryCheckNextItemExists(ref CollectionItemIterator propertyIterator,
 			return requestHint == 0;
 		}
 
-		public async ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, SampleObject obj)
+		public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, SampleObject obj)
 		{
-			// T が値型
+			// T が値�
 			// throw new NotSupportedException();
 
-			var buffer = context.ByteBufferPool.Rent(2 * 1024 * 1024);
-			try
-			{
-				var provider = new StreamReadOnlyMemoryProvider(streamSource, buffer);
-				var memory = await provider.GetNextAsync(default, 0, context.CancellationToken).ConfigureAwait(false);
-				int requestHint;
+			await source.FetchAsync(context.CancellationToken).ConfigureAwait(false);
+			var sequence = source.Sequence;
+			int requestHint;
 
 #if STRING
-				string name = default!;
+			string name = default!;
 #endif
 #if INT32
-				int age = default;
+			int age = default;
 #endif
 #if BOOL
-				bool isActive = default;
+			bool isActive = default;
 #endif
 #if COLLECTION
-				var roles = obj.Roles;
-				var attributes = obj.Attributes;
+			var roles = obj.Roles;
+			var attributes = obj.Attributes;
 #endif
 
-				var decoder = context.Decoder;
-				context.IncrementDepth();
+			var decoder = context.Decoder;
+			context.IncrementDepth();
 
-				long itemsCount;
-				CollectionType arrayOrMap;
-				CollectionItemIterator propertyIterator;
-				while (!TryDecodeArrayOrMapHeader(context, ref memory, out itemsCount, out arrayOrMap, out propertyIterator, out requestHint))
-				{
-					memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-				}
+			long itemsCount;
+			CollectionType arrayOrMap;
+			CollectionItemIterator propertyIterator;
+			while (!TryDecodeArrayOrMapHeader(context, ref sequence, out itemsCount, out arrayOrMap, out propertyIterator, out requestHint))
+			{
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
 
-				if (arrayOrMap.IsNull)
-				{
-					return false;
-				}
+			if (arrayOrMap.IsNull)
+			{
+				return false;
+			}
 
-				// Instantiate when Deserialize
+			// Instantiate when Deserialize
 
-				// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
-				if (arrayOrMap.IsArray)
-				{
+			// If !SerializerGenerationOptions.InfersObjectSerialization && SerializerGenerationOptions.UseArray || typeof(T).IsDefined([SerializeAs(Array)])
+			if (arrayOrMap.IsArray)
+			{
 #if STRING
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 					}
+				}
 
-					while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
+				while (!TryDecodeValueOfName(context, ref sequence, out name, out requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+				}
 #endif
 
 #if INT32
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 					}
+				}
 
-					while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
+				while (!TryDecodeValueOfAge(context, ref sequence, out age, out requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+				}
 #endif
 
 #if BOOL
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 					}
+				}
 
-					while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
+				while (!TryDecodeValueOfIsActive(context, ref sequence, out isActive, out requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+				}
 #endif
 
 #if COLLECTION
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 					}
+				}
 
-					context.IncrementDepth();
+				context.IncrementDepth();
 
-					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					long arrayLength;
+					while (!TryDecodeArrayHeader(context, ref sequence, out arrayLength, out requestHint))
 					{
-						long arrayLength;
-						while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
 
-						// If settable
-						//if (roles == null)
-						//{
-						//	roles = new List<string>(arrayLength); // or 0
-						//}
+					// If settable
+					//if (roles == null)
+					//{
+					//	roles = new List<string>(arrayLength); // or 0
+					//}
 
-						for (var i = 0; i < arrayLength; i++)
+					for (var i = 0; i < arrayLength; i++)
+					{
+						string item;
+						while (!TryDecodeItemOfRoles(context, ref sequence, out item, out requestHint))
 						{
-							string item;
-							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							roles.Add(item);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
+						roles.Add(item);
 					}
-					else
+				}
+				else
+				{
+					CollectionItemIterator iterator;
+					while (!TryDecodeArray(context, ref sequence, out iterator, out requestHint))
 					{
-						CollectionItemIterator iterator;
-						while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
 
-						while (!iterator.CollectionEnds(memory, out requestHint))
+					while (!iterator.CollectionEnds(sequence, out requestHint))
+					{
+						if (requestHint != 0)
 						{
-							if (requestHint != 0)
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-
-							string item;
-							while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							roles.Add(item);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
 
-						while (!iterator.Drain(ref memory, out requestHint))
+						string item;
+						while (!TryDecodeItemOfRoles(context, ref sequence, out item, out requestHint))
 						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
+						roles.Add(item);
 					}
-					context.DecrementDepth();
 
-					if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+					while (!iterator.Drain(ref sequence, out requestHint))
 					{
-						while (!this.TryCheckNextItemExists(ref propertyIterator, memory, out requestHint))
-						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-						}
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 					}
+				}
+				context.DecrementDepth();
 
-					context.IncrementDepth();
-					if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
+					{
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+
+				context.IncrementDepth();
+				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				{
+					long mapCount;
+					while (!TryDecodeMapHeader(context, ref sequence, out mapCount, out requestHint))
+					{
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+
+					// If settable
+					//if (attributes == null)
+					//{
+					//	attributes = new Dictionary<string, string>(mapCount); // or 0
+					//}
+					for (var i = 0; i < mapCount; i++)
 					{
-						long mapCount;
-						while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
+						string key;
+						while (!TryDecodeKeyOfAttributes(context, ref sequence, out key, out requestHint))
 						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
-
-						// If settable
-						//if (attributes == null)
-						//{
-						//	attributes = new Dictionary<string, string>(mapCount); // or 0
-						//}
-						for (var i = 0; i < mapCount; i++)
+						string value;
+						while (!TryDecodeValueOfAttributes(context, ref sequence, out value, out requestHint))
 						{
-							string key;
-							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							string value;
-							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							attributes.Add(key, value);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
+						attributes.Add(key, value);
 					}
-					else
+				}
+				else
+				{
+					CollectionItemIterator iterator;
+					while (!TryDecodeMap(context, ref sequence, out iterator, out requestHint))
 					{
-						CollectionItemIterator iterator;
-						while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+
+					while (!iterator.CollectionEnds(sequence, out requestHint))
+					{
+						if (requestHint != 0)
 						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
 
-						while (!iterator.CollectionEnds(memory, out requestHint))
+						string key;
+						while (!TryDecodeKeyOfAttributes(context, ref sequence, out key, out requestHint))
 						{
-							if (requestHint != 0)
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-
-							string key;
-							while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							string value;
-							while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
-							attributes.Add(key, value);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
-
-						while (!iterator.Drain(ref memory, out requestHint))
+						string value;
+						while (!TryDecodeValueOfAttributes(context, ref sequence, out value, out requestHint))
 						{
-							memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 						}
+						attributes.Add(key, value);
+					}
+
+					while (!iterator.Drain(ref sequence, out requestHint))
+					{
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 					}
-					context.DecrementDepth();
-#endif
 				}
-				else
+				context.DecrementDepth();
+#endif
+			}
+			else
+			{
+				// Map
+				// #if !context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				// while (!propertyIterator.CollectionEnds(memory, out requestHint))
+				// {
+				//  	if (requestHint != 0)
+				//  	{
+				//  		memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+				//			continue;
+				//  	}
+				for (var i = 0; i < itemsCount; i++)
 				{
-					// Map
-					// #if !context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
-					// while (!propertyIterator.CollectionEnds(memory, out requestHint))
-					// {
-					//  	if (requestHint != 0)
-					//  	{
-					//  		memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					//			continue;
-					//  	}
-					for (var i = 0; i < itemsCount; i++)
+					byte[] propertyKeyArray = null!;
+					try
 					{
-						byte[] propertyKey = null!;
-						try
+						ReadOnlyMemory<byte> propertyKey;
+						while (!TryGetRawString(context, ref sequence, out propertyKeyArray, out propertyKey, out requestHint))
 						{
-							while (!TryGetRawString(context, ref memory, out propertyKey, out requestHint))
-							{
-								memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-							}
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
 
-							// Use inlined trie, prefixed by the count as MP uint32.
-							// char is UTF-8, big endian.
-							// 1st node: [length(1-5)][chars(7-3)]
-							switch (DeserializationTrie.GetOrDefault(propertyKey))
-							{
+						// Use inlined trie, prefixed by the count as MP uint32.
+						// char is UTF-8, big endian.
+						// 1st node: [length(1-5)][chars(7-3)]
+						switch (DeserializationTrie.GetOrDefault(propertyKey.Span))
+						{
 #if STRING
-								case 0:
+							case 0:
+							{
+								while (!TryDecodeValueOfName(context, ref sequence, out name, out requestHint))
 								{
-									while (!TryDecodeValueOfName(context, ref memory, out name, out requestHint))
-									{
-										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-									}
-
-									break;
+									await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 								}
+
+								break;
+							}
 #endif
 #if INT32
-								case 1:
+							case 1:
+							{
+								while (!TryDecodeValueOfAge(context, ref sequence, out age, out requestHint))
 								{
-									while (!TryDecodeValueOfAge(context, ref memory, out age, out requestHint))
-									{
-										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-									}
-
-									break;
+									await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 								}
+
+								break;
+							}
 #endif
 #if BOOL
-								case 2:
+							case 2:
+							{
+								while (!TryDecodeValueOfIsActive(context, ref sequence, out isActive, out requestHint))
 								{
-									while (!TryDecodeValueOfIsActive(context, ref memory, out isActive, out requestHint))
-									{
-										memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-									}
-
-									break;
+									await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 								}
+
+								break;
+							}
 #endif
 #if COLLECTION
-								case 3:
+							case 3:
+							{
+								context.IncrementDepth();
+								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
 								{
-									context.IncrementDepth();
-									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+									long arrayLength;
+									while (!TryDecodeArrayHeader(context, ref sequence, out arrayLength, out requestHint))
 									{
-										long arrayLength;
-										while (!TryDecodeArrayHeader(context, ref memory, out arrayLength, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
+										await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
 
-										// If settable
-										//if (roles == null)
-										//{
-										//	roles = new List<string>(arrayLength); // or 0
-										//}
-										for (var j = 0; j < arrayLength; j++)
+									// If settable
+									//if (roles == null)
+									//{
+									//	roles = new List<string>(arrayLength); // or 0
+									//}
+									for (var j = 0; j < arrayLength; j++)
+									{
+										string item;
+										while (!TryDecodeItemOfRoles(context, ref sequence, out item, out requestHint))
 										{
-											string item;
-											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											roles.Add(item);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
+
+										roles.Add(item);
 									}
-									else
+								}
+								else
+								{
+									CollectionItemIterator iterator;
+									while (!TryDecodeArray(context, ref sequence, out iterator, out requestHint))
 									{
-										CollectionItemIterator iterator;
-										while (!TryDecodeArray(context, ref memory, out iterator, out requestHint))
-										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-										}
+										await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
 
-										while (!iterator.CollectionEnds(memory, out requestHint))
+									while (!iterator.CollectionEnds(sequence, out requestHint))
+									{
+										if (requestHint != 0)
 										{
-											if (requestHint != 0)
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											string item;
-											while (!TryDecodeItemOfRoles(context, ref memory, out item, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											roles.Add(item);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
 
-										while (!iterator.Drain(ref memory, out requestHint))
+										string item;
+										while (!TryDecodeItemOfRoles(context, ref sequence, out item, out requestHint))
 										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
+
+										roles.Add(item);
+									}
+
+									while (!iterator.Drain(ref sequence, out requestHint))
+									{
+										await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 									}
-									context.DecrementDepth();
-									break;
 								}
-								case 4:
+								context.DecrementDepth();
+								break;
+							}
+							case 4:
+							{
+								context.IncrementDepth();
+								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
 								{
-									context.IncrementDepth();
-									if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+									long mapCount;
+									while (!TryDecodeMapHeader(context, ref sequence, out mapCount, out requestHint))
+									{
+										await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+									}
+
+									// If settable
+									//if (attributes == null)
+									//{
+									//	attributes = new Dictionary<string, string>(mapCount); // or 0
+									//}
+									for (var j = 0; j < mapCount; j++)
 									{
-										long mapCount;
-										while (!TryDecodeMapHeader(context, ref memory, out mapCount, out requestHint))
+										string key;
+										while (!TryDecodeKeyOfAttributes(context, ref sequence, out key, out requestHint))
 										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
-
-										// If settable
-										//if (attributes == null)
-										//{
-										//	attributes = new Dictionary<string, string>(mapCount); // or 0
-										//}
-										for (var j = 0; j < mapCount; j++)
+										string value;
+										while (!TryDecodeValueOfAttributes(context, ref sequence, out value, out requestHint))
 										{
-											string key;
-											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-											string value;
-											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											attributes.Add(key, value);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
+
+										attributes.Add(key, value);
+									}
+								}
+								else
+								{
+									CollectionItemIterator iterator;
+									while (!TryDecodeMap(context, ref sequence, out iterator, out requestHint))
+									{
+										await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 									}
-									else
+
+									while (!iterator.CollectionEnds(sequence, out requestHint))
 									{
-										CollectionItemIterator iterator;
-										while (!TryDecodeMap(context, ref memory, out iterator, out requestHint))
+										if (requestHint != 0)
 										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
 
-										while (!iterator.CollectionEnds(memory, out requestHint))
+										string key;
+										while (!TryDecodeKeyOfAttributes(context, ref sequence, out key, out requestHint))
 										{
-											if (requestHint != 0)
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											string key;
-											while (!TryDecodeKeyOfAttributes(context, ref memory, out key, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-											string value;
-											while (!TryDecodeValueOfAttributes(context, ref memory, out value, out requestHint))
-											{
-												memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-											}
-
-											attributes.Add(key, value);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
-
-										while (!iterator.Drain(ref memory, out requestHint))
+										string value;
+										while (!TryDecodeValueOfAttributes(context, ref sequence, out value, out requestHint))
 										{
-											memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
+											await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 										}
+
+										attributes.Add(key, value);
+									}
+
+									while (!iterator.Drain(ref sequence, out requestHint))
+									{
+										await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 									}
-									context.DecrementDepth();
-									break;
 								}
+								context.DecrementDepth();
+								break;
+							}
 #endif
-								default:
-								{
+							default:
+							{
 #warning TODO: TrySkip loop
-									break;
-								}
+								break;
 							}
 						}
-						finally
+					}
+					finally
+					{
+						if (propertyKeyArray != null)
 						{
-							if (propertyKey != null)
-							{
-								context.ByteBufferPool.Return(propertyKey);
-							}
+							context.ByteBufferPool.Return(propertyKeyArray);
 						}
 					}
 				}
+			}
 
-				if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			{
+				itemsCount -= 5;
+				while (!TryDrain(context, ref sequence, itemsCount, out requestHint))
 				{
-					itemsCount -= 5;
-					while (!TryDrain(context, ref memory, itemsCount, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 				}
-				else
+			}
+			else
+			{
+				while (!propertyIterator.Drain(ref sequence, out requestHint))
 				{
-					while (!propertyIterator.Drain(ref memory, out requestHint))
-					{
-						memory = await provider.GetNextAsync(memory, requestHint, context.CancellationToken).ConfigureAwait(false);
-					}
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 				}
+			}
 
-				context.DecrementDepth();
+			context.DecrementDepth();
 
-				// Verbose for Deserialize...
+			// Verbose for Deserialize...
 #if STRING
-				obj.Name = name;
+			obj.Name = name;
 #endif
 #if INT32
-				obj.Age = age;
+			obj.Age = age;
 #endif
 #if BOOL
-				obj.IsActive = isActive;
+			obj.IsActive = isActive;
 #endif
-				// If settable
-				// obj.Roles = roles;
-				// If settable
-				// obj.Attributes = attributes;
-				return true;
-			}
-			finally
-			{
-				context.ByteBufferPool.Return(buffer, clearArray: true);
-			}
+			// If settable
+			// obj.Roles = roles;
+			// If settable
+			// obj.Attributes = attributes;
+			return true;
 		}
 	}
 
-	public sealed class SampleInt32ArraySerializer<TExtensionType> : IObjectSerializer<int[], TExtensionType>
+	public sealed class SampleInt32ArraySerializer : ObjectSerializer<int[]>
 	{
-		public void Serialize(ref SerializationOperationContext<TExtensionType> context, int[] obj, IBufferWriter<byte> sink)
+		public SampleInt32ArraySerializer(ObjectSerializationContext ownedContext)
+			: base(ownedContext, SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) { }
+
+		public sealed override void Serialize(ref SerializationOperationContext context, int[] obj, IBufferWriter<byte> sink)
 		{
 			if (obj is null)
 			{
@@ -1921,12 +1910,7 @@ public void Serialize(ref SerializationOperationContext<TExtensionType> context,
 			context.Encoder.EncodeArrayEnd(obj.Length, sink, context.CollectionContext);
 		}
 
-		public ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, int[] obj, Stream streamSink)
-		{
-			throw new NotImplementedException();
-		}
-
-		public int[] Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source)
+		public sealed override int[] Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
 		{
 			if (context.Decoder.FormatFeatures.CanCountCollectionItems)
 			{
@@ -1952,50 +1936,48 @@ public int[] Deserialize(ref DeserializationOperationContext<TExtensionType> con
 			}
 		}
 
-		public ValueTask<int[]> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		public sealed override ValueTask<int[]> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence streamSource)
 		{
 			throw new NotImplementedException();
 		}
 
-		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source, in int[] obj)
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in int[] obj)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, int[] obj)
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence streamSource, int[] obj)
 		{
 			throw new NotImplementedException();
 		}
 	}
 
-	public sealed class SampleInt32Serializer<TExtensionType> : IObjectSerializer<int, TExtensionType>
+	public sealed class SampleInt32Serializer : ObjectSerializer<int>
 	{
-		public void Serialize(ref SerializationOperationContext<TExtensionType> context, int obj, IBufferWriter<byte> sink)
-		{
-			context.Encoder.EncodeInt32(obj, sink);
-		}
+		public SampleInt32Serializer(ObjectSerializationContext ownedContext)
+			: base(ownedContext, SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) { }
 
-		public ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, int obj, Stream streamSink)
+		public sealed override void Serialize(ref SerializationOperationContext context, int obj, IBufferWriter<byte> sink)
 		{
-			throw new NotImplementedException();
+			context.Encoder.EncodeInt32(obj, sink);
 		}
 
-		public int Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source)
+		public sealed override int Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
 		{
 			return context.Decoder.DecodeInt32(ref source);
 		}
 
-		public ValueTask<int> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
+		public sealed override ValueTask<int> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence streamSource)
 		{
 			throw new NotImplementedException();
 		}
 
-		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source, in int obj)
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in int obj)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, int obj)
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence streamSource, int obj)
 		{
 			throw new NotImplementedException();
 		}

From 4be2eeadae2d24ffe0673f6e091c5c05105a05c8 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 23 Jun 2020 19:25:37 +0900
Subject: [PATCH 29/82] Fix collection count values types because it can never
 exceed Int32.MaxValue in .net

---
 .../Internal/FormatDecoder.cs                 | 12 +++----
 .../MessagePackDecoder.CollectionHeaders.cs   | 32 ++++++++-----------
 .../Json/JsonDecoder.CollectionHeaders.cs     |  6 ++--
 src/MsgPack.Json/Json/JsonThrow.cs            |  4 +--
 test/Benchmark/_SampleObject.cs               |  7 ++--
 5 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
index 20e0b154e..70ff70f0d 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
@@ -85,7 +85,7 @@ public bool TryDecodeNull(ref SequenceReader<byte> source)
 		///	<exception cref="MessageTypeException">The decoded value is not an array nor a map.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount)
+		public CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out int itemsCount)
 		{
 			var result = this.DecodeArrayOrMapHeader(ref source, out itemsCount, out var requestHint);
 			if (requestHint != 0)
@@ -110,7 +110,7 @@ public CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, ou
 		///		This method does not return anything else, but may throw an exception.
 		///	</returns>
 		///	<exception cref="MessageTypeException">The decoded value is not an array nor a map.</exception>
-		public abstract CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount, out int requestHint);
+		public abstract CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out int itemsCount, out int requestHint);
 
 		/// <summary>
 		///		Decodes current data as array header, and returns the items count if known.
@@ -123,7 +123,7 @@ public CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, ou
 		///	<exception cref="MessageTypeException">The decoded value is not an array.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public long DecodeArrayHeader(ref SequenceReader<byte> source)
+		public int DecodeArrayHeader(ref SequenceReader<byte> source)
 		{
 			var result = this.DecodeArrayHeader(ref source, out var requestHint);
 			if (requestHint != 0)
@@ -148,7 +148,7 @@ public long DecodeArrayHeader(ref SequenceReader<byte> source)
 		///	</returns>
 		///	<exception cref="MessageTypeException">The decoded value is not an array.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public abstract long DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint);
+		public abstract int DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
 		///		Decodes current data as map header, and returns the items count if known.
@@ -161,7 +161,7 @@ public long DecodeArrayHeader(ref SequenceReader<byte> source)
 		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public long DecodeMapHeader(ref SequenceReader<byte> source)
+		public int DecodeMapHeader(ref SequenceReader<byte> source)
 		{
 			var result = this.DecodeMapHeader(ref source, out var requestHint);
 			if (requestHint != 0)
@@ -185,7 +185,7 @@ public long DecodeMapHeader(ref SequenceReader<byte> source)
 		///		Note that <c>0</c> is valid value when the map is empty.
 		///	</returns>
 		///	<exception cref="MessageTypeException">The decoded value is not a map.</exception>
-		public abstract long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint);
+		public abstract int DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint);
 
 		public virtual void DecodeExtension(ref SequenceReader<byte> source, out ExtensionTypeObject result, out int requestHint, CancellationToken cancellationToken = default)
 		{
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
index e2f6bf09a..7b2436854 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.CollectionHeaders.cs
@@ -9,7 +9,7 @@ namespace MsgPack.Internal
 {
 	public partial class MessagePackDecoder
 	{
-		public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount, out int requestHint)
+		public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out int itemsCount, out int requestHint)
 		{
 			var startOffset = source.Consumed;
 			var result = this.PrivateDecodeArrayOrMapHeader(ref source, out var header, out itemsCount, out requestHint);
@@ -22,7 +22,7 @@ public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<
 			return result;
 		}
 
-		private CollectionType PrivateDecodeArrayOrMapHeader(ref SequenceReader<byte> source, out byte header, out long itemsCount, out int requestHint)
+		private CollectionType PrivateDecodeArrayOrMapHeader(ref SequenceReader<byte> source, out byte header, out int itemsCount, out int requestHint)
 		{
 			var startOffset = source.Consumed;
 			var result = this.DecodeArrayOrMapHeaderCore(ref source, out header, out itemsCount, out requestHint);
@@ -34,7 +34,7 @@ private CollectionType PrivateDecodeArrayOrMapHeader(ref SequenceReader<byte> so
 			return result;
 		}
 
-		private CollectionType DecodeArrayOrMapHeaderCore(ref SequenceReader<byte> source, out byte header, out long itemsCount, out int requestHint)
+		private CollectionType DecodeArrayOrMapHeaderCore(ref SequenceReader<byte> source, out byte header, out int itemsCount, out int requestHint)
 		{
 			if (!source.TryRead(out header))
 			{
@@ -53,13 +53,13 @@ private CollectionType DecodeArrayOrMapHeaderCore(ref SequenceReader<byte> sourc
 
 			if ((header & MessagePackCode.MinimumFixedArray) == MessagePackCode.MinimumFixedArray)
 			{
-				itemsCount = (uint)header - MessagePackCode.MinimumFixedArray;
+				itemsCount = (int)header - MessagePackCode.MinimumFixedArray;
 				return CollectionType.Array;
 			}
 
 			if ((header & MessagePackCode.MinimumFixedMap) == MessagePackCode.MinimumFixedMap)
 			{
-				itemsCount = (uint)header - MessagePackCode.MinimumFixedMap;
+				itemsCount = (int)header - MessagePackCode.MinimumFixedMap;
 				return CollectionType.Map;
 			}
 
@@ -108,7 +108,13 @@ private CollectionType DecodeArrayOrMapHeaderCore(ref SequenceReader<byte> sourc
 				}
 				default: // 4
 				{
-					itemsCount = ReadValue<uint>(ref source, offset: 1, out requestHint);
+					var count = ReadValue<uint>(ref source, offset: 1, out requestHint);
+					if (count > OptionsDefaults.MaxMultiByteCollectionLength)
+					{
+						MessagePackThrow.TooLargeArrayOrMapLength(header, source.Consumed - 1, count);
+					}
+
+					itemsCount = unchecked((int)count);
 					break;
 				}
 			}
@@ -122,7 +128,7 @@ private CollectionType DecodeArrayOrMapHeaderCore(ref SequenceReader<byte> sourc
 			return type;
 		}
 
-		public sealed override long DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint)
+		public sealed override int DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint)
 		{
 			var startOffset = source.Consumed;
 			var type = this.DecodeArrayOrMapHeaderCore(ref source, out var header, out var itemsCount, out requestHint);
@@ -131,11 +137,6 @@ public sealed override long DecodeArrayHeader(ref SequenceReader<byte> source, o
 				return 0;
 			}
 
-			if (itemsCount > Int32.MaxValue)
-			{
-				MessagePackThrow.TooLargeArrayOrMapLength(header, startOffset, itemsCount);
-			}
-
 			if (type.IsMap)
 			{
 				MessagePackThrow.TypeIsNotArray(header, startOffset);
@@ -144,7 +145,7 @@ public sealed override long DecodeArrayHeader(ref SequenceReader<byte> source, o
 			return (int)itemsCount;
 		}
 
-		public sealed override long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint)
+		public sealed override int DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint)
 		{
 			var startOffset = source.Consumed;
 			var type = this.DecodeArrayOrMapHeaderCore(ref source, out var header, out var itemsCount, out requestHint);
@@ -153,11 +154,6 @@ public sealed override long DecodeMapHeader(ref SequenceReader<byte> source, out
 				return 0;
 			}
 
-			if (itemsCount > Int32.MaxValue)
-			{
-				MessagePackThrow.TooLargeArrayOrMapLength(header, startOffset, itemsCount);
-			}
-
 			if (type.IsArray)
 			{
 				MessagePackThrow.TypeIsNotMap(header, startOffset);
diff --git a/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs b/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
index c5f94307c..afe416a8d 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.CollectionHeaders.cs
@@ -9,13 +9,13 @@ namespace MsgPack.Json
 {
 	public partial class JsonDecoder
 	{
-		public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out long itemsCount, out int requestHint)
+		public sealed override CollectionType DecodeArrayOrMapHeader(ref SequenceReader<byte> source, out int itemsCount, out int requestHint)
 			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out itemsCount, out requestHint);
 
-		public sealed override long DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint)
+		public sealed override int DecodeArrayHeader(ref SequenceReader<byte> source, out int requestHint)
 			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out requestHint);
 
-		public sealed override long DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint)
+		public sealed override int DecodeMapHeader(ref SequenceReader<byte> source, out int requestHint)
 			=> JsonThrow.CollectionHeaderDecodingIsNotSupported(out requestHint);
 	}
 }
diff --git a/src/MsgPack.Json/Json/JsonThrow.cs b/src/MsgPack.Json/Json/JsonThrow.cs
index f26a1053f..96beb6918 100644
--- a/src/MsgPack.Json/Json/JsonThrow.cs
+++ b/src/MsgPack.Json/Json/JsonThrow.cs
@@ -16,10 +16,10 @@ internal static class JsonThrow
 		public static void TooShortUtf8()
 			=> throw new FormatException($"Input UTF-8 sequence is invalid. The sequence unexpectedly ends.");
 
-		public static CollectionType CollectionHeaderDecodingIsNotSupported(out long itemsCount, out int requestHint)
+		public static CollectionType CollectionHeaderDecodingIsNotSupported(out int itemsCount, out int requestHint)
 			=> throw new NotSupportedException("JSON does not support collection length.");
 
-		public static long CollectionHeaderDecodingIsNotSupported(out int requestHint)
+		public static int CollectionHeaderDecodingIsNotSupported(out int requestHint)
 			=> throw new NotSupportedException("JSON does not support collection length.");
 
 		public static void DrainIsNotSupported(out int requestHint)
diff --git a/test/Benchmark/_SampleObject.cs b/test/Benchmark/_SampleObject.cs
index 4675f9997..f2562501d 100644
--- a/test/Benchmark/_SampleObject.cs
+++ b/test/Benchmark/_SampleObject.cs
@@ -668,7 +668,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 			var decoder = new MessagePackDecoder(context.Decoder.Options as MessagePackDecoderOptions);
 #endif
 			CollectionType arrayOrMap;
-			long itemsCount;
+			int itemsCount;
 			CollectionItemIterator propertyIterator;
 
 			if (this.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
@@ -1225,7 +1225,7 @@ private static void CheckNextItemExists(ref SequenceReader<byte> reader, ref Col
 			}
 		}
 
-		private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out long itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
+		private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationContext context, ref ReadOnlySequence<byte> sequence, out int itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
 		{
 			context.IncrementDepth();
 			var reader = new SequenceReader<byte>(sequence);
@@ -1442,8 +1442,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 
 			var decoder = context.Decoder;
 			context.IncrementDepth();
-
-			long itemsCount;
+			int itemsCount;
 			CollectionType arrayOrMap;
 			CollectionItemIterator propertyIterator;
 			while (!TryDecodeArrayOrMapHeader(context, ref sequence, out itemsCount, out arrayOrMap, out propertyIterator, out requestHint))

From 9dfdf3eba5a55bd21113dd47682775042db50b82 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 23 Jun 2020 23:56:40 +0900
Subject: [PATCH 30/82] Change StreamReadOnlyMemoryProvider struct to
 ReadOnlyStreamSequence

This change ease async serializer implementation so much.
---
 .../Internal/CollectionItemIterator.cs        |   9 +-
 .../Internal/ReadOnlyStreamSequence.cs        | 122 ++++++++++++++++++
 .../Internal/StreamReadOnlyMemoryProvider.cs  |  75 -----------
 ...lizationOperationContext.StreamSequence.cs |  22 ++++
 .../AsyncDeserializationOperationContext.cs   |   2 +-
 .../AsyncSerializationOperationContext.cs     |   2 +-
 .../Serialization/DeserializationOptions.cs   |   5 +-
 .../DeserializationOptionsBuilder.cs          |   4 +-
 .../Serialization/ObjectSerializer`1.cs       |   4 +-
 .../Serialization/OperationContext.ttinclude  |   2 +-
 .../Serialization/Serializer.cs               |   2 +-
 .../Serialization/Serializer`2.cs             |   4 +-
 src/MsgPack.Abstraction/Throw.cs              |   3 +
 13 files changed, 167 insertions(+), 89 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
 delete mode 100644 src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
 create mode 100644 src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs

diff --git a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
index 9fa613652..9af56e2cb 100644
--- a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
+++ b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
@@ -10,6 +10,7 @@ namespace MsgPack.Internal
 {
 	public struct CollectionItemIterator
 	{
+#warning TODO: in SequenceReader<byte> ??
 		public delegate bool CollectionEndDetection(ref SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint);
 
 		private readonly long _itemsCount;
@@ -43,9 +44,9 @@ public bool CollectionEnds(ref SequenceReader<byte> source, out int requestHint)
 			=> this._collectionEnds(ref source, ref this._nextItemIndex, this._itemsCount, out requestHint);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public bool CollectionEnds(ReadOnlyMemory<byte> source, out int requestHint)
+		public bool CollectionEnds(in ReadOnlySequence<byte> source, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(source));
+			var reader = new SequenceReader<byte>(source);
 			return this.CollectionEnds(ref reader, out requestHint);
 		}
 
@@ -73,9 +74,9 @@ public bool Drain(ref SequenceReader<byte> source, out int requestHint)
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public bool Drain(ref ReadOnlyMemory<byte> source, out int requestHint)
+		public bool Drain(ref ReadOnlySequence<byte> source, out int requestHint)
 		{
-			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(source));
+			var reader = new SequenceReader<byte>(source);
 			var ends = this.Drain(ref reader, out requestHint);
 			source = source.Slice((int)reader.Consumed);
 			return ends;
diff --git a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
new file mode 100644
index 000000000..e7c53f904
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
@@ -0,0 +1,122 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Wraps <see cref="Stream"/> and provides <see cref="ReadOnlySequence{T}"/> via internal buffer.
+	/// </summary>
+	/// <remarks>
+	///		User of this object must be call <see cref="Dispose()"/> when this sequence used.
+	///		Note that the <see cref="Stream"/> will NOT be closed when <see cref="Dispose()"/> is called.
+	/// </remarks>
+	public sealed class ReadOnlyStreamSequence : IDisposable
+	{
+		private readonly ArrayPool<byte> _arrayPool;
+		private readonly bool _clearsBuffer;
+		private readonly Stream _stream; // DO NOT Dispose this in this class.
+		private byte[] _array;
+
+		/// <summary>
+		///		Gets internal buffer as <see cref="ReadOnlyMemory{Byte}"/> which holds last fetched data.
+		/// </summary>
+		public ReadOnlyMemory<byte> Memory { get; private set; }
+
+		/// <summary>
+		///		Gets internal buffer as <see cref="ReadOnlySequence{Byte}"/> which holds last fetched data.
+		/// </summary>
+		public ReadOnlySequence<byte> Sequence => new ReadOnlySequence<byte>(this.Memory);
+
+		internal ReadOnlyStreamSequence(Stream stream, ArrayPool<byte> arrayPool, int bufferSize, bool clearsBuffer)
+		{
+			this._stream = stream;
+			this._arrayPool = arrayPool;
+			this._array = arrayPool.Rent(bufferSize);
+			this.Memory = this._array;
+			this._clearsBuffer = clearsBuffer;
+		}
+
+		/// <inheritdoc />
+		public void Dispose()
+		{
+			var array = Interlocked.Exchange(ref this._array, null!);
+			if (array != null)
+			{
+				this._arrayPool.Return(this._array, this._clearsBuffer);
+			}
+		}
+
+		/// <summary>
+		///		Fetches first data from underlying <see cref="Stream"/> and fills internal buffer.
+		///		Remaining data in the current buffer will be included new buffer.
+		/// </summary>
+		/// <param name="cancellationToken"><see cref="CancellationToken"/> to cancel read operation.</param>
+		/// <returns>Async operation state.</returns>
+		/// <exception cref="ObjectDisposedException">This object is already disposed.</exception>
+		public ValueTask FetchAsync(CancellationToken cancellationToken)
+			=> this.FetchAsync(0, cancellationToken);
+
+		/// <summary>
+		///		Fetches next data from underlying <see cref="Stream"/> and fills internal buffer.
+		///		Remaining data in the current buffer will be included new buffer.
+		/// </summary>
+		/// <param name="requestHint">
+		///		Hint size to fetch from <see cref="Stream"/>.
+		///		<c>0</c> is valid value which means that the implementation fetches bytes from <see cref="Stream"/> to fill out current buffer.
+		///		Note that it is not guaranteed that <see cref="Memory"/> contains this length because underlying <see cref="Stream"/> may not have enough data.
+		///	</param>
+		/// <param name="cancellationToken"><see cref="CancellationToken"/> to cancel read operation.</param>
+		/// <returns>Async operation state.</returns>
+		/// <exception cref="ObjectDisposedException">This object is already disposed.</exception>
+		public async ValueTask FetchAsync(int requestHint, CancellationToken cancellationToken)
+		{
+			if (this._array == null)
+			{
+				Throw.ObjectDisposed(this.ToString());
+				// never
+				return;
+			}
+
+			var existingLength = this.Memory.Length;
+			if (existingLength + requestHint > this._array.Length)
+			{
+				// realloc
+				var newArray = this._arrayPool.Rent(Math.Max(this._array.Length * 2, existingLength + requestHint));
+				this.Memory.CopyTo(newArray);
+				this._arrayPool.Return(this._array, this._clearsBuffer);
+				this._array = newArray;
+			}
+			else
+			{
+				// comact
+				this.Memory.CopyTo(this._array);
+			}
+
+			var readLength = await this._stream.ReadAsync(this._array.AsMemory(existingLength), cancellationToken).ConfigureAwait(false);
+			this.Memory = this._array.AsMemory(existingLength + readLength);
+		}
+
+		/// <summary>
+		///		Advances internal buffer position.
+		/// </summary>
+		/// <param name="length">Length to be advanced.</param>
+		/// <exception cref="ArgumentOutOfRangeException"><paramref name="length"/> is greater than length of <see cref="Memory"/>.</exception>
+		/// <exception cref="ObjectDisposedException">This object is already disposed.</exception>
+		public void Advance(int length)
+		{
+			if (this._array == null)
+			{
+				Throw.ObjectDisposed(this.ToString());
+			}
+
+			this.Memory = this.Memory.Slice(Ensure.IsNotGreaterThan(length, this.Memory.Length));
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs b/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
deleted file mode 100644
index 0934bbbdf..000000000
--- a/src/MsgPack.Abstraction/Internal/StreamReadOnlyMemoryProvider.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MsgPack.Internal
-{
-	public struct StreamReadOnlyMemoryProvider
-	{
-		private readonly Stream _stream;
-		private readonly byte[] _buffer;
-
-		public StreamReadOnlyMemoryProvider(Stream stream, byte[] buffer)
-		{
-			Ensure.NotNull(stream);
-			if (!stream.CanRead)
-			{
-				Throw.StreamMustBeAbleToRead(nameof(stream));
-			}
-
-			Ensure.NotNull(buffer);
-			if (buffer.Length == 0)
-			{
-				Throw.TooSmallBuffer(nameof(buffer), 1);
-			}
-
-			this._stream = stream;
-			this._buffer = buffer;
-		}
-
-		public async ValueTask<ReadOnlyMemory<byte>> GetNextAsync(ReadOnlyMemory<byte> previous, int requestHint, CancellationToken cancellationToken)
-		{
-			if (this._stream is null)
-			{
-				Throw.EmptyObject(typeof(StreamReadOnlyMemoryProvider));
-				// never
-				return default;
-			}
-
-			var required = (long)previous.Length + requestHint;
-			if (required > OptionsDefaults.MaxSingleByteCollectionLength)
-			{
-				Throw.TooLargeLength(previous.Length, requestHint);
-			}
-
-			Memory<byte> buffer;
-			if (required < this._buffer.Length)
-			{
-				if (previous.Length > 0)
-				{
-					this._buffer.AsSpan().CopyTo(this._buffer.AsSpan(previous.Length));
-				}
-
-				buffer = this._buffer.AsMemory(previous.Length);
-				if (requestHint > 0)
-				{
-					buffer = buffer.Slice(0, requestHint);
-				}
-			}
-			else
-			{
-				buffer = new byte[required];
-				previous.CopyTo(buffer);
-				buffer = buffer.Slice(previous.Length);
-			}
-
-			await this._stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-			return buffer;
-		}
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
new file mode 100644
index 000000000..f2a0fc553
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
@@ -0,0 +1,22 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.IO;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	public partial class AsyncDeserializationOperationContext
+	{
+		/// <summary>
+		///		Returns new <see cref="ReadOnlyStreamSequence"/> which wraps specified <see cref="Stream"/>.
+		/// </summary>
+		/// <param name="stream"><see cref="Stream"/> which holds input data, it may have over 32bit length.</param>
+		/// <returns></returns>
+		/// <exception cref="ArgumentException"><paramref name="stream"/> is <c>null</c>.</exception>
+		public ReadOnlyStreamSequence CreateSequence(Stream stream)
+			=> new ReadOnlyStreamSequence(Ensure.NotNull(stream), this.Options.ByteBufferPool, 64 * 1024, this.Options.ClearsBuffer);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
index 70a1d3911..3df936d93 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
@@ -16,7 +16,7 @@
 
 namespace MsgPack.Serialization
 {
-	public sealed class AsyncDeserializationOperationContext
+	public sealed partial class AsyncDeserializationOperationContext
 	{
 		public FormatDecoder Decoder { get; }
 		public DeserializationOptions Options { get; }
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
index 0bd040e1f..9b2ffe7fb 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
@@ -15,7 +15,7 @@
 
 namespace MsgPack.Serialization
 {
-	public sealed class AsyncSerializationOperationContext
+	public sealed partial class AsyncSerializationOperationContext
 	{
 		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
index 7f7f81ccf..350b97c29 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
@@ -17,6 +17,7 @@ public sealed class DeserializationOptions
 		public int MaxDepth { get; }
 		public Encoding? StringEncoding { get; }
 		public ArrayPool<byte> ByteBufferPool { get; }
+		public bool ClearsBuffer { get; }
 
 		internal DeserializationOptions(
 			int maxArrayLength,
@@ -24,7 +25,8 @@ internal DeserializationOptions(
 			int maxPropertyKeyLength,
 			int maxDepth,
 			Encoding? stringEncoding,
-			ArrayPool<byte> arrayPool
+			ArrayPool<byte> arrayPool,
+			bool clearsBuffer
 		)
 		{
 			this.MaxArrayLength =maxArrayLength;
@@ -33,6 +35,7 @@ ArrayPool<byte> arrayPool
 			this.MaxDepth = maxDepth;
 			this.StringEncoding = stringEncoding;
 			this.ByteBufferPool = arrayPool;
+			this.ClearsBuffer = clearsBuffer;
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
index 3b965806f..a83ea3310 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
@@ -46,7 +46,9 @@ public int MaxDepth
 
 		public ArrayPool<byte>? ArrayPool { get; set; }
 
+		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
+
 		public DeserializationOptions Create()
-			=> new DeserializationOptions(this.MaxArrayLength, this.MaxMapCount, this.MaxPropertyKeyLength, this.MaxDepth, this.StringEncoding, this.ArrayPool ?? ArrayPool<byte>.Shared);
+			=> new DeserializationOptions(this.MaxArrayLength, this.MaxMapCount, this.MaxPropertyKeyLength, this.MaxDepth, this.StringEncoding, this.ArrayPool ?? ArrayPool<byte>.Shared, this.ClearsBuffer);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
index 2cdd62ec6..2775ab89d 100644
--- a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
@@ -36,8 +36,8 @@ public async ValueTask SerializeAsync(AsyncSerializationOperationContext context
 
 		[return: MaybeNull]
 		public abstract T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
-		public abstract ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, Stream streamSource);
+		public abstract ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source);
 		public abstract bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in T obj);
-		public abstract ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, Stream streamSource, T obj);
+		public abstract ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
index 9335f56b1..e4c516f34 100644
--- a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
+++ b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
@@ -1,7 +1,7 @@
 <#+
 void WriteContext(bool isSerialization, bool isAsync)
 {
-	var typeClass = isAsync ? "sealed class" : "struct";
+	var typeClass = isAsync ? "sealed partial class" : "struct";
 	var typePrefix = isSerialization ? "Serialization" : "Deserialization";
 	var typeName = $"{(isAsync ? "Async" : String.Empty)}{typePrefix}OperationContext";
 	var optionTypeName = $"{typePrefix}Options";
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer.cs b/src/MsgPack.Abstraction/Serialization/Serializer.cs
index a07d09f2f..c43c4e611 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer.cs
+++ b/src/MsgPack.Abstraction/Serialization/Serializer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
index f0b9fd72f..a33e61069 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
+++ b/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
@@ -124,7 +124,7 @@ public T Deserialize(ref ReadOnlyMemory<byte> memorySource, CancellationToken ca
 		public ValueTask<T> DeserializeAsync(Stream streamSource, CancellationToken cancellationToken = default)
 		{
 			this.InitializeAsyncDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.DeserializeAsync(context, streamSource);
+			return this._underlying.DeserializeAsync(context, context.CreateSequence(streamSource));
 		}
 
 		public bool DeserializeTo(ref SequenceReader<byte> reader, T obj, CancellationToken cancellationToken = default)
@@ -154,7 +154,7 @@ public bool DeserializeTo(ref ReadOnlyMemory<byte> memorySource, T obj, Cancella
 		public ValueTask<bool> DeserializeToAsync(Stream streamSource, T obj, CancellationToken cancellationToken = default)
 		{
 			this.InitializeAsyncDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.DeserializeToAsync(context, streamSource, obj);
+			return this._underlying.DeserializeToAsync(context, context.CreateSequence(streamSource), obj);
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Throw.cs b/src/MsgPack.Abstraction/Throw.cs
index 4d67dc451..3ef1c8d47 100644
--- a/src/MsgPack.Abstraction/Throw.cs
+++ b/src/MsgPack.Abstraction/Throw.cs
@@ -16,6 +16,9 @@ public static void ArgumentNull(string paramName)
 		public static void ArgumentOutOfRange(string paramName, string message)
 			=> throw new ArgumentOutOfRangeException(paramName, message);
 
+		public static void ObjectDisposed(string? name)
+			=> throw new ObjectDisposedException(name);
+
 		public static void ExtensionsIsNotSupported()
 			=> throw new NotSupportedException($"Extension type is not supported in this encoder.");
 

From 4abac45973c9d63ed56bee3f4787aee887eaf697 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Fri, 26 Jun 2020 20:18:57 +0900
Subject: [PATCH 31/82] Change Advance method's parameter type to Int64

---
 src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
index e7c53f904..e5e9acaa7 100644
--- a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
+++ b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
@@ -109,14 +109,14 @@ public async ValueTask FetchAsync(int requestHint, CancellationToken cancellatio
 		/// <param name="length">Length to be advanced.</param>
 		/// <exception cref="ArgumentOutOfRangeException"><paramref name="length"/> is greater than length of <see cref="Memory"/>.</exception>
 		/// <exception cref="ObjectDisposedException">This object is already disposed.</exception>
-		public void Advance(int length)
+		public void Advance(long length)
 		{
 			if (this._array == null)
 			{
 				Throw.ObjectDisposed(this.ToString());
 			}
 
-			this.Memory = this.Memory.Slice(Ensure.IsNotGreaterThan(length, this.Memory.Length));
+			this.Memory = this.Memory.Slice((int)Ensure.IsNotGreaterThan(length, (long)this.Memory.Length));
 		}
 	}
 }

From c749e4cfb734774b5b931c7a806176688a31436d Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sun, 28 Jun 2020 11:43:00 +0900
Subject: [PATCH 32/82] Add StringEncodingAttribute

This class enable individual encoding specification for msgpack.
---
 .../Serialization/StringEncodingAttribute.cs  | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 src/MsgPack.Serialization/Serialization/StringEncodingAttribute.cs

diff --git a/src/MsgPack.Serialization/Serialization/StringEncodingAttribute.cs b/src/MsgPack.Serialization/Serialization/StringEncodingAttribute.cs
new file mode 100644
index 000000000..54f0fd666
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/StringEncodingAttribute.cs
@@ -0,0 +1,35 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Text;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Specifies <see cref="Encoding"/> for this member's value.
+	/// </summary>
+	public sealed class StringEncodingAttribute : Attribute
+	{
+		/// <summary>
+		///		Gets name of the encoding.
+		/// </summary>
+		/// <value>Name of the encoding.</value>
+		public string Name { get; }
+
+		internal Encoding Encoding { get; }
+
+		/// <summary>
+		///		Initializes new instance.
+		/// </summary>
+		/// <param name="name">
+		///		Name of the encoding. This value must be valid name for <see cref="Encoding.GetEncoding(String)"/>.
+		/// </param>
+		public StringEncodingAttribute(string name)
+		{
+			this.Name = Ensure.NotBlank(name);
+			this.Encoding = Encoding.GetEncoding(name, EncoderFallback.ExceptionFallback, DecoderFallback.ReplacementFallback);
+		}
+	}
+}

From 7cdfb7824185b31ffdcb2f1eaa75493c330d2e61 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 7 Jul 2020 21:16:14 +0900
Subject: [PATCH 33/82] Refine Ensure

* Add additional members.
* Independent from Throw for portability.
---
 src/MsgPack.Abstraction/Ensure.cs | 54 ++++++++++++++++++++++++++-----
 src/MsgPack.Abstraction/Throw.cs  |  6 ----
 2 files changed, 46 insertions(+), 14 deletions(-)

diff --git a/src/MsgPack.Abstraction/Ensure.cs b/src/MsgPack.Abstraction/Ensure.cs
index 0f2f62aae..18517a85d 100644
--- a/src/MsgPack.Abstraction/Ensure.cs
+++ b/src/MsgPack.Abstraction/Ensure.cs
@@ -3,7 +3,6 @@
 // See the LICENSE in the project root for more information.
 
 using System;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
@@ -16,8 +15,31 @@ public static T NotNull<T>([NotNull]T value, [CallerArgumentExpression("value")]
 		{
 			if (value == null)
 			{
-				Throw.ArgumentNull(paramName);
-				Debug.Assert(value != null);
+				ThrowArgumentNull(paramName);
+			}
+
+			return value;
+		}
+
+		public static string NotNullNorEmpty([NotNull]string? value, [CallerArgumentExpression("value")] string paramName = null!)
+		{
+			NotNull(value);
+
+			if (value.Length ==0)
+			{
+				ThrowArgumentEmptyString(paramName);
+			}
+
+			return value;
+		}
+
+		public static string NotBlank([NotNull] string? value, [CallerArgumentExpression("value")] string paramName = null!)
+		{
+			NotNull(value);
+
+			if (String.IsNullOrWhiteSpace(value))
+			{
+				ThrowArgumentBlankString(paramName);
 			}
 
 			return value;
@@ -27,7 +49,7 @@ public static int IsNotNegative(int value, [CallerArgumentExpression("value")]st
 		{
 			if (value < 0)
 			{
-				Throw.ArgumentOutOfRange(paramName, "Value cannot be negative number.");
+				ThrowArgumentOutOfRange(paramName, "Value cannot be negative number.");
 			}
 
 			return value;
@@ -38,7 +60,7 @@ public static T IsNotLessThan<T>(T value, T minInclusive, [CallerArgumentExpress
 		{
 			if (value.CompareTo(minInclusive) < 0)
 			{
-				Throw.ArgumentOutOfRange(paramName, $"Value cannot be less than {minInclusive}.");
+				ThrowArgumentOutOfRange(paramName, $"Value cannot be less than {minInclusive}.");
 			}
 
 			return value;
@@ -49,7 +71,7 @@ public static T IsNotGreaterThan<T>(T value, T maxInclusive, [CallerArgumentExpr
 		{
 			if (value.CompareTo(maxInclusive) > 0)
 			{
-				Throw.ArgumentOutOfRange(paramName, $"Value cannot be greater than {maxInclusive}.");
+				ThrowArgumentOutOfRange(paramName, $"Value cannot be greater than {maxInclusive}.");
 			}
 
 			return value;
@@ -60,15 +82,31 @@ public static T IsBetween<T>(T value, T minInclusive, T maxInclusive, [CallerArg
 		{
 			if (value.CompareTo(minInclusive) < 0)
 			{
-				Throw.ArgumentOutOfRange(paramName, $"Value cannot be less than {minInclusive}.");
+				ThrowArgumentOutOfRange(paramName, $"Value cannot be less than {minInclusive}.");
 			}
 
 			if (value.CompareTo(maxInclusive) > 0)
 			{
-				Throw.ArgumentOutOfRange(paramName, $"Value cannot be greater than {maxInclusive}.");
+				ThrowArgumentOutOfRange(paramName, $"Value cannot be greater than {maxInclusive}.");
 			}
 
 			return value;
 		}
+
+		[DoesNotReturn]
+		private static void ThrowArgumentNull(string paramName)
+			=> throw new ArgumentNullException(paramName);
+
+		[DoesNotReturn]
+		private static void ThrowArgumentOutOfRange(string paramName, string message)
+			=> throw new ArgumentOutOfRangeException(paramName, message);
+
+		[DoesNotReturn]
+		private static void ThrowArgumentEmptyString(string paramName)
+			=> throw new ArgumentException("Value cannot be empty string.", paramName);
+
+		[DoesNotReturn]
+		private static void ThrowArgumentBlankString(string paramName)
+			=> throw new ArgumentException("Value cannot be empty or blank string.", paramName);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Throw.cs b/src/MsgPack.Abstraction/Throw.cs
index 3ef1c8d47..3519f13f4 100644
--- a/src/MsgPack.Abstraction/Throw.cs
+++ b/src/MsgPack.Abstraction/Throw.cs
@@ -10,12 +10,6 @@ namespace MsgPack
 {
 	internal static class Throw
 	{
-		public static void ArgumentNull(string paramName)
-			=> throw new ArgumentNullException(paramName);
-
-		public static void ArgumentOutOfRange(string paramName, string message)
-			=> throw new ArgumentOutOfRangeException(paramName, message);
-
 		public static void ObjectDisposed(string? name)
 			=> throw new ObjectDisposedException(name);
 

From bbcf644c1e31d4ae02a394d773de1582f283367f Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 7 Jul 2020 21:18:53 +0900
Subject: [PATCH 34/82] Move FormatFeatures from decoder to encoder/decoder
 options

---
 .../Internal/FormatDecoder.cs                 |  5 +-
 .../Internal/FormatDecoderOptions.cs          |  5 +-
 .../Internal/FormatEncoderOptions.cs          |  5 +-
 .../Internal/MessagePackDecoder.cs            | 10 +---
 src/MsgPack.Json/Json/JsonDecoder.cs          | 11 +---
 src/MsgPack.Json/Json/JsonDecoderOptions.cs   |  2 +-
 src/MsgPack.Json/Json/JsonEncoderOptions.cs   |  2 +-
 src/MsgPack.Json/Json/JsonFormatFeatures.cs   | 23 +++++++++
 test/Benchmark/_SampleObject.cs               | 50 +++++++++----------
 9 files changed, 61 insertions(+), 52 deletions(-)
 create mode 100644 src/MsgPack.Json/Json/JsonFormatFeatures.cs

diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
index 70ff70f0d..632f3f7cc 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
@@ -19,14 +19,11 @@ namespace MsgPack.Internal
 	/// </remarks>
 	public abstract partial class FormatDecoder
 	{
-		public FormatFeatures FormatFeatures { get; }
-
 		public FormatDecoderOptions Options { get; }
 
-		protected FormatDecoder(FormatDecoderOptions options, FormatFeatures formatFeatures)
+		protected FormatDecoder(FormatDecoderOptions options)
 		{
 			this.Options = Ensure.NotNull(options);
-			this.FormatFeatures = Ensure.NotNull(formatFeatures);
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs b/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
index ef55e0238..59b6aac3a 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
@@ -28,7 +28,9 @@ public abstract class FormatDecoderOptions
 
 		public bool ClearsBuffer { get; }
 
-		protected FormatDecoderOptions(FormatDecoderOptionsBuilder builder)
+		public FormatFeatures Features { get; }
+
+		protected FormatDecoderOptions(FormatDecoderOptionsBuilder builder, FormatFeatures features)
 		{
 			builder = Ensure.NotNull(builder);
 
@@ -42,6 +44,7 @@ protected FormatDecoderOptions(FormatDecoderOptionsBuilder builder)
 			this.MaxNumberLengthInBytes = builder.MaxNumberLengthInBytes;
 			this.MaxStringLengthInBytes = builder.MaxStringLengthInBytes;
 			this.MaxBinaryLengthInBytes = builder.MaxBinaryLengthInBytes;
+			this.Features = Ensure.NotNull(features);
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs b/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
index 45a60a7d1..b78dd8720 100644
--- a/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
@@ -20,7 +20,9 @@ public abstract class FormatEncoderOptions
 
 		public bool ClearsBuffer { get; }
 
-		protected FormatEncoderOptions(FormatEncoderOptionsBuilder builder)
+		public FormatFeatures Features { get; }
+
+		protected FormatEncoderOptions(FormatEncoderOptionsBuilder builder, FormatFeatures features)
 		{
 			builder = Ensure.NotNull(builder);
 
@@ -30,6 +32,7 @@ protected FormatEncoderOptions(FormatEncoderOptionsBuilder builder)
 			this.ByteBufferPool = builder.ByteBufferPool;
 			this.CharBufferPool = builder.CharBufferPool;
 			this.ClearsBuffer = builder.ClearsBuffer;
+			this.Features = Ensure.NotNull(features);
 		}
 	}
 }
diff --git a/src/MsgPack.Core/Internal/MessagePackDecoder.cs b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
index 4bd24d4ca..f9dbd80d6 100644
--- a/src/MsgPack.Core/Internal/MessagePackDecoder.cs
+++ b/src/MsgPack.Core/Internal/MessagePackDecoder.cs
@@ -11,16 +11,8 @@ namespace MsgPack.Internal
 {
 	public sealed partial class MessagePackDecoder : FormatDecoder
 	{
-		private static readonly FormatFeatures MessagePackFormatFeatures =
-			new FormatFeaturesBuilder
-			{
-				IsContextful = false,
-				CanCountCollectionItems = true,
-				CanSpecifyStringEncoding = true
-			}.Build();
-
 		public MessagePackDecoder(MessagePackDecoderOptions options)
-			: base(options, MessagePackFormatFeatures)
+			: base(options)
 		{
 			this._detectCollectionEnds = this.DetectCollectionEnds;
 		}
diff --git a/src/MsgPack.Json/Json/JsonDecoder.cs b/src/MsgPack.Json/Json/JsonDecoder.cs
index 537d503fe..4de440a9e 100644
--- a/src/MsgPack.Json/Json/JsonDecoder.cs
+++ b/src/MsgPack.Json/Json/JsonDecoder.cs
@@ -14,19 +14,10 @@ namespace MsgPack.Json
 	/// </summary>
 	public abstract partial class JsonDecoder : FormatDecoder
 	{
-		private static readonly FormatFeatures JsonFormatFeatures =
-			new FormatFeaturesBuilder
-			{
-				CanCountCollectionItems = false,
-				CanSpecifyStringEncoding = false,
-				SupportsExtensionTypes = false,
-				IsContextful = true
-			}.Build();
-
 		public new JsonDecoderOptions Options { get; }
 
 		protected JsonDecoder(JsonDecoderOptions options)
-			: base(options, JsonFormatFeatures)
+			: base(options)
 		{
 			this.Options = options;
 		}
diff --git a/src/MsgPack.Json/Json/JsonDecoderOptions.cs b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
index 43f77b5e7..bbb295938 100644
--- a/src/MsgPack.Json/Json/JsonDecoderOptions.cs
+++ b/src/MsgPack.Json/Json/JsonDecoderOptions.cs
@@ -16,7 +16,7 @@ public class JsonDecoderOptions : FormatDecoderOptions
 		public JsonParseOptions ParseOptions { get; }
 
 		public JsonDecoderOptions(JsonDecoderOptionsBuilder builder)
-			: base(builder)
+			: base(builder, JsonFormatFeatures.Value)
 		{
 			this.ParseOptions = builder.ParseOptions;
 		}
diff --git a/src/MsgPack.Json/Json/JsonEncoderOptions.cs b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
index cc12fa8f3..0399e13b9 100644
--- a/src/MsgPack.Json/Json/JsonEncoderOptions.cs
+++ b/src/MsgPack.Json/Json/JsonEncoderOptions.cs
@@ -57,7 +57,7 @@ public sealed class JsonEncoderOptions : FormatEncoderOptions
 		internal ReadOnlyMemory<int> EscapeTargetChars4Byte { get; }
 
 		public JsonEncoderOptions(JsonEncoderOptionsBuilder builder)
-			: base(builder)
+			: base(builder, JsonFormatFeatures.Value)
 		{
 			this._singleInfinityFormatter =
 				builder.InfinityHandling switch
diff --git a/src/MsgPack.Json/Json/JsonFormatFeatures.cs b/src/MsgPack.Json/Json/JsonFormatFeatures.cs
new file mode 100644
index 000000000..d17149e58
--- /dev/null
+++ b/src/MsgPack.Json/Json/JsonFormatFeatures.cs
@@ -0,0 +1,23 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+using MsgPack.Serialization;
+
+namespace MsgPack.Json
+{
+	internal static class JsonFormatFeatures
+	{
+		public static FormatFeatures Value { get; } =
+			new FormatFeaturesBuilder("Json")
+			{
+				CanCountCollectionItems = false,
+				CanSpecifyStringEncoding = false,
+				IsContextful = false,
+				PreferredSerializationMethod = SerializationMethod.Map,
+				AvailableSerializationMethods = AvailableSerializationMethods.Map,
+				SupportsExtensionTypes = false
+			}.Build();
+	}
+}
diff --git a/test/Benchmark/_SampleObject.cs b/test/Benchmark/_SampleObject.cs
index f2562501d..fcd7bf93e 100644
--- a/test/Benchmark/_SampleObject.cs
+++ b/test/Benchmark/_SampleObject.cs
@@ -707,7 +707,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 			{
 #if STRING
 #if NO_OPT
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					CheckNextItemExists(ref reader, ref propertyIterator);
 				}
@@ -718,7 +718,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 
 #if INT32
 #if NO_OPT
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					CheckNextItemExists(ref reader, ref propertyIterator);
 				}
@@ -729,7 +729,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 
 #if BOOL
 #if NO_OPT
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					CheckNextItemExists(ref reader, ref propertyIterator);
 				}
@@ -740,7 +740,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 
 #if COLLECTION
 #if NO_OPT
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					CheckNextItemExists(ref reader, ref propertyIterator);
 				}
@@ -748,7 +748,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 
 				context.IncrementDepth();
 #if NO_OPT
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 #endif
 					var arrayLength = decoder.DecodeArrayHeader(ref reader);
@@ -777,14 +777,14 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 				context.DecrementDepth();
 
 #if NO_OPT
-				if (!decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					CheckNextItemExists(ref reader, ref propertyIterator);
 				}
 #endif
 				context.IncrementDepth();
 #if NO_OPT
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 #endif
 					var mapCount = decoder.DecodeMapHeader(ref reader);
@@ -822,7 +822,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 			{
 				// Map
 
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					for (var i = 0; i < itemsCount; i++)
 					{
@@ -916,7 +916,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 #endif
 #warning TODO: No Collection items deserialized!
 								context.IncrementDepth();
-								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 								{
 									var arrayLength = decoder.DecodeArrayHeader(ref reader);
 									// If settable
@@ -960,7 +960,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 							{
 #endif
 								context.IncrementDepth();
-								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 								{
 									var mapCount = decoder.DecodeMapHeader(ref reader);
 									// If settable
@@ -1096,7 +1096,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 #endif
 #warning TODO: No Collection items deserialized!
 								context.IncrementDepth();
-								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 								{
 									var arrayLength = decoder.DecodeArrayHeader(ref reader);
 									// If settable
@@ -1140,7 +1140,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 							{
 #endif
 								context.IncrementDepth();
-								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 								{
 									var mapCount = decoder.DecodeMapHeader(ref reader);
 									// If settable
@@ -1186,7 +1186,7 @@ public sealed override bool DeserializeTo(ref DeserializationOperationContext co
 			}
 
 #if NO_OPT
-			if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 			{
 #endif
 				decoder.Drain(ref reader, context.CollectionContext, itemsCount - 5, context.CancellationToken);
@@ -1237,7 +1237,7 @@ private static bool TryDecodeArrayOrMapHeader(AsyncDeserializationOperationConte
 				return false;
 			}
 
-			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			if (context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 			{
 				arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(ref reader, out itemsCount);
 				if (itemsCount < 5)
@@ -1461,7 +1461,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 			if (arrayOrMap.IsArray)
 			{
 #if STRING
-				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
@@ -1476,7 +1476,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 #endif
 
 #if INT32
-				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
@@ -1491,7 +1491,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 #endif
 
 #if BOOL
-				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
@@ -1506,7 +1506,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 #endif
 
 #if COLLECTION
-				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
@@ -1516,7 +1516,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 
 				context.IncrementDepth();
 
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					long arrayLength;
 					while (!TryDecodeArrayHeader(context, ref sequence, out arrayLength, out requestHint))
@@ -1570,7 +1570,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 				}
 				context.DecrementDepth();
 
-				if (!context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (!context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					while (!this.TryCheckNextItemExists(ref propertyIterator, sequence, out requestHint))
 					{
@@ -1579,7 +1579,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 				}
 
 				context.IncrementDepth();
-				if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+				if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 				{
 					long mapCount;
 					while (!TryDecodeMapHeader(context, ref sequence, out mapCount, out requestHint))
@@ -1707,7 +1707,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 							case 3:
 							{
 								context.IncrementDepth();
-								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 								{
 									long arrayLength;
 									while (!TryDecodeArrayHeader(context, ref sequence, out arrayLength, out requestHint))
@@ -1766,7 +1766,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 							case 4:
 							{
 								context.IncrementDepth();
-								if (decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+								if (decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 								{
 									long mapCount;
 									while (!TryDecodeMapHeader(context, ref sequence, out mapCount, out requestHint))
@@ -1850,7 +1850,7 @@ public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializa
 				}
 			}
 
-			if (context.Decoder.FormatFeatures.CanCountCollectionItems) // OPTIMIZABLE
+			if (context.Decoder.Options.Features.CanCountCollectionItems) // OPTIMIZABLE
 			{
 				itemsCount -= 5;
 				while (!TryDrain(context, ref sequence, itemsCount, out requestHint))
@@ -1911,7 +1911,7 @@ public sealed override void Serialize(ref SerializationOperationContext context,
 
 		public sealed override int[] Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
 		{
-			if (context.Decoder.FormatFeatures.CanCountCollectionItems)
+			if (context.Decoder.Options.Features.CanCountCollectionItems)
 			{
 				var length = context.Decoder.DecodeArrayHeader(ref source);
 				var result = new int[length];

From fbc8f0257709a27271476fcae2d751ce47880d9c Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 7 Jul 2020 21:20:05 +0900
Subject: [PATCH 35/82] Add SerializationMethod for options

This commit also refactor builder and constructor relationship.
---
 .../Internal/FormatFeatures.cs                | 29 +++++++++++++++++++
 .../Internal/FormatFeaturesBuilder.cs         | 10 +++++++
 .../Internal/OptionsDefaults.cs               |  2 ++
 .../MsgPack.Abstraction.csproj                |  3 +-
 .../AsyncSerializationOperationContext.cs     |  2 ++
 .../AvailableSerializationMethods.cs          | 16 ++++++++++
 .../ObjectSerializationContext.cs             | 12 ++++++--
 .../Serialization/OperationContext.ttinclude  | 21 ++++++++++++--
 .../SerializationOperationContext.cs          |  2 ++
 .../Serialization/SerializationOptions.cs     | 29 ++++++++++++++++---
 .../SerializationOptionsBuilder.cs            |  9 ++++--
 test/Benchmark/_SampleObject.cs               |  9 ++++--
 12 files changed, 129 insertions(+), 15 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Serialization/AvailableSerializationMethods.cs

diff --git a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
index 4b490fa21..03cd0439e 100644
--- a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
@@ -2,6 +2,8 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using MsgPack.Serialization;
+
 namespace MsgPack.Internal
 {
 	public sealed class FormatFeatures
@@ -9,6 +11,8 @@ public sealed class FormatFeatures
 #warning TODO: REMOVE
 		public bool IsContextful { get; }
 
+		public string Name { get; }
+
 		/// <summary>
 		///		Gets a value which indicates the underlying format supports collection length.
 		/// </summary>
@@ -58,12 +62,37 @@ public sealed class FormatFeatures
 		/// </remarks>
 		public bool SupportsExtensionTypes { get; }
 
+		public SerializationMethod PreferredSerializationMethod { get; }
+		public AvailableSerializationMethods AvailableSerializationMethods { get; }
+
 		internal FormatFeatures(FormatFeaturesBuilder builder)
 		{
+			this.Name = builder.Name;
 			this.IsContextful = builder.IsContextful;
 			this.CanCountCollectionItems = builder.CanCountCollectionItems;
 			this.CanSpecifyStringEncoding = builder.CanSpecifyStringEncoding;
 			this.SupportsExtensionTypes = builder.SupportsExtensionTypes;
+			this.PreferredSerializationMethod = builder.PreferredSerializationMethod;
+			this.AvailableSerializationMethods = builder.AvailableSerializationMethods;
+		}
+
+		internal SerializationMethod GetSerializationMethod(SerializationMethod? contextPreferredMethod)
+		{
+			if (contextPreferredMethod == null)
+			{
+				return this.PreferredSerializationMethod;
+			}
+
+			if (contextPreferredMethod == SerializationMethod.Array && (this.AvailableSerializationMethods & AvailableSerializationMethods.Array) == 0)
+			{
+				Throw.UnavailableMethod(this.Name, SerializationMethod.Array);
+			}
+			else if ((this.AvailableSerializationMethods & AvailableSerializationMethods.Map) == 0)
+			{
+				Throw.UnavailableMethod(this.Name, SerializationMethod.Map);
+			}
+
+			return contextPreferredMethod.GetValueOrDefault();
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
index 66aa16c24..d08d617f9 100644
--- a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
@@ -2,14 +2,24 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using MsgPack.Serialization;
+
 namespace MsgPack.Internal
 {
 	public sealed class FormatFeaturesBuilder
 	{
+		public string Name { get; }
 		public bool IsContextful { get; set; }
 		public bool CanCountCollectionItems { get; set; }
 		public bool CanSpecifyStringEncoding { get; set; }
 		public bool SupportsExtensionTypes { get; set; }
+		public SerializationMethod PreferredSerializationMethod { get; set; }
+		public AvailableSerializationMethods AvailableSerializationMethods { get; set; }
+
+		public FormatFeaturesBuilder(string name)
+		{
+			this.Name = Ensure.NotBlank(name).Trim();
+		}
 
 		public FormatFeatures Build() => new FormatFeatures(this);
 	}
diff --git a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
index a8ecbb089..84ddac7cf 100644
--- a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
+++ b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
@@ -3,6 +3,7 @@
 // See the LICENSE in the project root for more information.
 
 using System.Buffers;
+using MsgPack.Serialization;
 
 namespace MsgPack.Internal
 {
@@ -26,5 +27,6 @@ internal static class OptionsDefaults
 		public static readonly ArrayPool<char> CharBufferPool = ArrayPool<char>.Shared;
 		public static readonly bool ClearsBuffer = true;
 		public static readonly bool CanTreatRealAsInteger = true;
+		public static readonly SerializationMethod? PreferredSerializationMethod = null;
 	}
 }
diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
index 965c43fb5..f5cc62568 100644
--- a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
@@ -7,6 +7,7 @@
   <ItemGroup>
     <Compile Include="../MsgPack/MessageNotSupportedException.cs" Link="MessageNotSupportedException.cs" />
     <Compile Include="../MsgPack/MessageTypeException.cs" Link="MessageTypeException.cs" />
+    <Compile Include="..\MsgPack\Serialization\SerializationMethod.cs" Link="Serialization\SerializationMethod.cs" />
     <Compile Include="..\MsgPack\Serialization\SerializerCapabilities.cs" Link="Serialization\SerializerCapabilities.cs" />
   </ItemGroup>
 
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
index 9b2ffe7fb..5f5a6ad23 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
@@ -20,6 +20,7 @@ public sealed partial class AsyncSerializationOperationContext
 		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public SerializationMethod SerializationMethod { get; }
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
@@ -29,6 +30,7 @@ public AsyncSerializationOperationContext(FormatEncoder encoder, SerializationOp
 			this.Options = options ?? SerializationOptions.Default;
 			this.CurrentDepth = 0;
 			this.CancellationToken = cancellationToken;
+			this.SerializationMethod = encoder.Options.Features.GetSerializationMethod(this.Options.PreferredSerializationMethod);
 		}
 
 		public SerializationOperationContext AsSerializationOperationContext()
diff --git a/src/MsgPack.Abstraction/Serialization/AvailableSerializationMethods.cs b/src/MsgPack.Abstraction/Serialization/AvailableSerializationMethods.cs
new file mode 100644
index 000000000..e0efe48c3
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/AvailableSerializationMethods.cs
@@ -0,0 +1,16 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	[Flags]
+	public enum AvailableSerializationMethods
+	{
+		None = 0,
+		Array = 0x1,
+		Map = 0x2
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
index d4f86ba0b..fe78f0051 100644
--- a/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -6,10 +6,16 @@
 
 namespace MsgPack.Serialization
 {
-#warning TODO: Remove UGLY TExtensionType
 	public sealed class ObjectSerializationContext
 	{
-		public ObjectSerializer<T> GetSerializer<T>(object providerParameter)
+		public SerializationOptions Options { get; }
+
+		public ObjectSerializer<T> GetSerializer<T>(object? providerParameter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
 		{
 			throw new NotImplementedException();
 		}
diff --git a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
index e4c516f34..511ab8e92 100644
--- a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
+++ b/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
@@ -7,6 +7,7 @@ void WriteContext(bool isSerialization, bool isAsync)
 	var optionTypeName = $"{typePrefix}Options";
 	var primitiveType = isSerialization ? "FormatEncoder" : "FormatDecoder";
 	var primitiveName = isSerialization ? "Encoder" : "Decoder";
+	var primitiveVariable = primitiveName.ToLowerInvariant();
 #>
 // Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
@@ -39,7 +40,13 @@ namespace MsgPack.Serialization
 		public <#= optionTypeName #> Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
 <#+
-	if (!isSerialization)
+	if (isSerialization)
+	{
+#>
+		public SerializationMethod SerializationMethod { get; }
+<#+
+	}
+	else
 	{
 #>
 		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
@@ -49,12 +56,20 @@ namespace MsgPack.Serialization
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
-		public <#= typeName #>(<#= primitiveType #> <#= primitiveName.ToLowerInvariant() #>, <#= optionTypeName #>? options, CancellationToken cancellationToken)
+		public <#= typeName #>(<#= primitiveType #> <#= primitiveVariable #>, <#= optionTypeName #>? options, CancellationToken cancellationToken)
 		{
-			this.<#= primitiveName #> = Ensure.NotNull(<#= primitiveName.ToLowerInvariant() #>);
+			this.<#= primitiveName #> = Ensure.NotNull(<#= primitiveVariable #>);
 			this.Options = options ?? <#= optionTypeName #>.Default;
 			this.CurrentDepth = 0;
 			this.CancellationToken = cancellationToken;
+<#+
+	if (isSerialization)
+	{
+#>
+			this.SerializationMethod = <#= primitiveVariable #>.Options.Features.GetSerializationMethod(this.Options.PreferredSerializationMethod);
+<#+
+	}
+#>
 		}
 
 <#+
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
index 75d24d1c2..c96a2e500 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
@@ -20,6 +20,7 @@ public struct SerializationOperationContext
 		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
 		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public SerializationMethod SerializationMethod { get; }
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
 
@@ -29,6 +30,7 @@ public SerializationOperationContext(FormatEncoder encoder, SerializationOptions
 			this.Options = options ?? SerializationOptions.Default;
 			this.CurrentDepth = 0;
 			this.CancellationToken = cancellationToken;
+			this.SerializationMethod = encoder.Options.Features.GetSerializationMethod(this.Options.PreferredSerializationMethod);
 		}
 
 		public CollectionContext CollectionContext => new CollectionContext(Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, this.CurrentDepth);
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
index 0b9d8d13d..5aab3b4f2 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
@@ -14,13 +14,34 @@ public sealed class SerializationOptions
 
 		public Encoding? StringEncoding { get; }
 
+		public SerializationMethod? PreferredSerializationMethod { get; }
+
+		/// <summary>
+		///		Gets or sets a value indicating whether generated and/or reflection serializers should not access non public members via privileged reflection.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if privileged reflection access is disabled; otherwise, <c>false</c>. Defaults to <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		The privileged reflection means:
+		///		<list type="bullet">
+		///			<item>Access for non-public fields or property accessors via reflection. This operation requires <c>ReflectionPermission</c> of <c>MemberAccess</c> or <c>RestrictedMemberAccess</c>.</item>
+		///			<item>Writing values for init only fields via reflection. This operation requires <c>SecurityPermission</c> of <c>SerializationFormatter</c>.</item>
+		///		</list>
+		///		If the program run on non-privileged Silverlight environment or restricted desktop CLR,
+		///		serialization and deserialization should fail with <c>SecurityException</c>.
+		/// </remarks>
+		public bool DisablePrivilegedAccess { get; }
+
+
 		internal SerializationOptions(
-			int maxDepth,
-			Encoding? stringEncoding
+			SerializationOptionsBuilder builder
 		)
 		{
-			this.MaxDepth = maxDepth;
-			this.StringEncoding = stringEncoding;
+			this.MaxDepth = builder.MaxDepth;
+			this.StringEncoding = builder.StringEncoding;
+			this.PreferredSerializationMethod = builder.PreferredSerializationMethod;
+			this.DisablePrivilegedAccess = builder.DisablePrivilegedAccess;
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
index 0f6475495..2e9d82986 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
@@ -2,6 +2,7 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using System.Text;
 using MsgPack.Internal;
 
 namespace MsgPack.Serialization
@@ -16,9 +17,13 @@ public int MaxDepth
 			set => this._maxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
 		}
 
-		public System.Text.Encoding? StringEncoding { get; set; }
+		public Encoding? StringEncoding { get; set; }
+
+		public SerializationMethod? PreferredSerializationMethod { get; set; } = OptionsDefaults.PreferredSerializationMethod;
+
+		public bool DisablePrivilegedAccess { get; set; }
 
 		public SerializationOptions Create()
-			=> new SerializationOptions(this.MaxDepth, this.StringEncoding);
+			=> new SerializationOptions(this);
 	}
 }
diff --git a/test/Benchmark/_SampleObject.cs b/test/Benchmark/_SampleObject.cs
index fcd7bf93e..5d3e547a7 100644
--- a/test/Benchmark/_SampleObject.cs
+++ b/test/Benchmark/_SampleObject.cs
@@ -72,7 +72,6 @@ public static SerializationFormat GetMessagePack(this SerializationFormatFactory
 			=> isCurrent ? CurrentMessagePackSerializationFormat : LegacyMessagePackSerializationFormat;
 	}
 
-
 	public static class JsonSerializationFormatFactoryExtensions
 	{
 		private static readonly SerializationFormat SimpleJsonSerializationFormat =
@@ -200,7 +199,13 @@ public SampleSerializer(ObjectSerializationContext ownedContext)
 			= true;
 #endif
 		private FormatFeatures FormatFeatures { get; set; } =
-			new FormatFeaturesBuilder
+			new FormatFeaturesBuilder(
+#if MSGPACK
+				"msgpack"
+#else
+				"json"
+#endif
+			)
 			{
 #if MSGPACK
 				CanCountCollectionItems = true,

From b189d681f0416aa251a78cee939e74f14cbe39cb Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 7 Jul 2020 21:21:21 +0900
Subject: [PATCH 36/82] Add StringBuilder overload for EncodeString

---
 .../Internal/FormatEncoder.cs                 | 12 ++++
 .../Internal/StringBuilderExtensions.cs       | 60 +++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 src/MsgPack.Abstraction/Internal/StringBuilderExtensions.cs

diff --git a/src/MsgPack.Abstraction/Internal/FormatEncoder.cs b/src/MsgPack.Abstraction/Internal/FormatEncoder.cs
index 6e85ef2a1..928c1e26c 100644
--- a/src/MsgPack.Abstraction/Internal/FormatEncoder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoder.cs
@@ -49,6 +49,18 @@ public void EncodeString(string? value, IBufferWriter<byte> buffer, Encoding? en
 			this.EncodeString(value.AsSpan(), buffer, encoding, cancellationToken);
 		}
 
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public void EncodeString(StringBuilder? value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			if (value == null)
+			{
+				this.EncodeNull(buffer);
+				return;
+			}
+
+			this.EncodeString(value.ToSequence(), buffer, encoding, cancellationToken);
+		}
+
 		public abstract void EncodeString(ReadOnlySpan<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 		public abstract void EncodeString(in ReadOnlySequence<char> value, IBufferWriter<byte> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default);
diff --git a/src/MsgPack.Abstraction/Internal/StringBuilderExtensions.cs b/src/MsgPack.Abstraction/Internal/StringBuilderExtensions.cs
new file mode 100644
index 000000000..9b3e380ec
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/StringBuilderExtensions.cs
@@ -0,0 +1,60 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MsgPack.Internal
+{
+	internal static partial class StringBuilderExtensions
+	{
+		public static ReadOnlySequence<char> ToSequence(this StringBuilder builder)
+		{
+			var runningIndex = 0L;
+			var firstSegment = default(StringBuilderChunkSegment);
+			var lastSegment = default(StringBuilderChunkSegment);
+			foreach(var chunk in builder.GetChunks())
+			{
+				if (chunk.IsEmpty)
+				{
+					continue;
+				}
+
+				var segment = new StringBuilderChunkSegment(chunk, runningIndex);
+				runningIndex += chunk.Length;
+				if (lastSegment == null)
+				{
+					firstSegment = segment;
+				}
+				else
+				{
+					lastSegment.SetNext(segment);
+				}
+
+				lastSegment = segment;
+			}
+
+			if (lastSegment == null)
+			{
+				return ReadOnlySequence<char>.Empty;
+			}
+
+			return new ReadOnlySequence<char>(firstSegment!, 0, lastSegment, lastSegment.Memory.Length - 1);
+		}
+
+		private sealed class StringBuilderChunkSegment : ReadOnlySequenceSegment<char>
+		{
+			public void SetNext(StringBuilderChunkSegment next)
+				=> this.Next = next;
+
+			public StringBuilderChunkSegment(ReadOnlyMemory<char> chunk, long runningIndex)
+			{
+				this.Memory = chunk;
+				this.RunningIndex = runningIndex;
+			}
+		}
+	}
+}

From 5370aeb9673b31f260a66a93b1e6c051c95a46aa Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 7 Jul 2020 21:22:01 +0900
Subject: [PATCH 37/82] Define object based serializer interface

This commit also fix DeserializeTo method design. It should only available for mutable collection, so `in` modifier is not suitable.
---
 .../Serialization/ObjectSerializer.cs         | 43 ++++++++++++++
 .../Serialization/ObjectSerializer`1.cs       | 57 +++++++++++++++----
 src/MsgPack.Abstraction/Throw.cs              |  8 +++
 test/Benchmark/_SampleObject.cs               |  6 +-
 4 files changed, 100 insertions(+), 14 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs

diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs
new file mode 100644
index 000000000..bc65229c1
--- /dev/null
+++ b/src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs
@@ -0,0 +1,43 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	public abstract class ObjectSerializer
+	{
+		protected ObjectSerializationContext OwnerContext { get; }
+		public SerializerCapabilities Capabilities { get; }
+		public bool CanSerialize => (this.Capabilities & SerializerCapabilities.Serialize) != 0;
+		public bool CanDeserialize => (this.Capabilities & SerializerCapabilities.Deserialize) != 0;
+		public bool CanDeserializeTo => (this.Capabilities & SerializerCapabilities.DeserializeTo) != 0;
+
+		protected ObjectSerializer(ObjectSerializationContext ownerContext, SerializerCapabilities capabilities)
+		{
+			this.OwnerContext = Ensure.NotNull(ownerContext);
+			this.Capabilities = capabilities;
+		}
+
+		public abstract void SerializeObject(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink);
+		public async ValueTask SerializeObjectAsync(AsyncSerializationOperationContext context, object? obj, Stream streamSink)
+		{
+			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
+			{
+				var serializationOperationContext = context.AsSerializationOperationContext();
+				this.SerializeObject(ref serializationOperationContext, obj, writer);
+			}
+		}
+
+		[return: MaybeNull]
+		public abstract object? DeserializeObject(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+		public abstract ValueTask<object?> DeserializeObjectAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source);
+		public abstract bool DeserializeObjectTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj);
+		public abstract ValueTask<bool> DeserializeObjectToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
index 2775ab89d..67f688870 100644
--- a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
+++ b/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
@@ -2,29 +2,28 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using System;
 using System.Buffers;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using MsgPack.Internal;
 
 namespace MsgPack.Serialization
 {
-	public abstract class ObjectSerializer<T>
+	public abstract class ObjectSerializer<T> : ObjectSerializer
 	{
-		protected ObjectSerializationContext OwnerContext { get; }
-		public SerializerCapabilities Capabilities { get; }
-		public bool CanSerialize => (this.Capabilities & SerializerCapabilities.Serialize) != 0;
-		public bool CanDeserialize => (this.Capabilities & SerializerCapabilities.Deserialize) != 0;
-		public bool CanDeserializeTo => (this.Capabilities & SerializerCapabilities.DeserializeTo) != 0;
+		private static readonly bool CanBeNull = !typeof(T).IsValueType || Nullable.GetUnderlyingType(typeof(T)) != null;
 
 		protected ObjectSerializer(ObjectSerializationContext ownerContext, SerializerCapabilities capabilities)
-		{
-			this.OwnerContext = Ensure.NotNull(ownerContext);
-			this.Capabilities = capabilities;
-		}
+			: base(ownerContext, capabilities) { }
 
 		public abstract void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink);
+
+		public sealed override void SerializeObject(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
+			=> this.Serialize(ref context, Cast(obj), sink);
+
 		public async ValueTask SerializeAsync(AsyncSerializationOperationContext context, [AllowNull] T obj, Stream streamSink)
 		{
 			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
@@ -36,8 +35,44 @@ public async ValueTask SerializeAsync(AsyncSerializationOperationContext context
 
 		[return: MaybeNull]
 		public abstract T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+
+		public sealed override object? DeserializeObject(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> this.Deserialize(ref context, ref source);
+
 		public abstract ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source);
-		public abstract bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in T obj);
+
+		public sealed override async ValueTask<object?> DeserializeObjectAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+			=> await this.DeserializeAsync(context, source).ConfigureAwait(false);
+
+		public abstract bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj);
+
+		public sealed override bool DeserializeObjectTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+			=> this.DeserializeTo(ref context, ref source, Cast(obj)!);
+
 		public abstract ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj);
+
+		public sealed override async ValueTask<bool> DeserializeObjectToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+			=> await this.DeserializeObjectToAsync(context, source, Cast(obj)).ConfigureAwait(false);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		[return: MaybeNull]
+		[return: NotNullIfNotNull("obj")]
+		private static T Cast(object? obj)
+		{
+			if (!(obj is null))
+			{
+				return (T)obj;
+			}
+			else if (CanBeNull)
+			{
+				return (T)obj;
+			}
+			else
+			{
+				Throw.CannotBeNull(typeof(T));
+				// never
+				return default;
+			}
+		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Throw.cs b/src/MsgPack.Abstraction/Throw.cs
index 3519f13f4..7e86a40d0 100644
--- a/src/MsgPack.Abstraction/Throw.cs
+++ b/src/MsgPack.Abstraction/Throw.cs
@@ -3,8 +3,10 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+using System.Runtime.Serialization;
 using System.Text;
 using MsgPack.Internal;
+using MsgPack.Serialization;
 
 namespace MsgPack
 {
@@ -86,6 +88,9 @@ public static void InsufficientInputForDecodeArrayOrMapHeader(long position, int
 			}
 		}
 
+		public static void CannotBeNull(Type type)
+			 => throw new SerializationException($"Value of type '{type}' cannot be null.");
+
 		public static void InsufficientInputForDecodeArrayHeader(long position, int requestHint)
 		{
 			if (requestHint < 0)
@@ -98,6 +103,9 @@ public static void InsufficientInputForDecodeArrayHeader(long position, int requ
 			}
 		}
 
+		public static void UnavailableMethod(string name, SerializationMethod array)
+			=> throw new NotSupportedException($"SerializationMethod '{array}' is not supported in '{name}' format.");
+
 		public static void InsufficientInputForDecodeMapHeader(long position, int requestHint)
 		{
 			if (requestHint < 0)
diff --git a/test/Benchmark/_SampleObject.cs b/test/Benchmark/_SampleObject.cs
index 5d3e547a7..d174c920f 100644
--- a/test/Benchmark/_SampleObject.cs
+++ b/test/Benchmark/_SampleObject.cs
@@ -633,7 +633,7 @@ public sealed override async ValueTask<SampleObject> DeserializeAsync(AsyncDeser
 		private static void ThrowNotEnoughItems(long actual, int expected)
 			=> throw new MessageTypeException();
 
-		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> reader, in SampleObject obj)
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> reader, SampleObject obj)
 		{
 			const int propertyCount =
 					0
@@ -1945,7 +1945,7 @@ public sealed override ValueTask<int[]> DeserializeAsync(AsyncDeserializationOpe
 			throw new NotImplementedException();
 		}
 
-		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in int[] obj)
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, int[] obj)
 		{
 			throw new NotImplementedException();
 		}
@@ -1976,7 +1976,7 @@ public sealed override ValueTask<int> DeserializeAsync(AsyncDeserializationOpera
 			throw new NotImplementedException();
 		}
 
-		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, in int obj)
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, int obj)
 		{
 			throw new NotImplementedException();
 		}

From 1791e9a2aa3f0695c6bb0ca585845f577178c5e0 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 7 Jul 2020 21:47:19 +0900
Subject: [PATCH 38/82] Add initial Reflection based serializer (builder)

---
 .../MsgPack.Serialization.Reflection.csproj   |  21 +-
 .../Internal/AsyncDecodeHelpers.Primitives.cs | 567 ++++++++++++
 .../Internal/AsyncDecodeHelpers.Primitives.tt |  87 ++
 .../Internal/AsyncDecodeHelpers.cs            | 224 +++++
 .../Internal/CollectionTypeAndCount.cs        |  20 +
 .../Internal/CollectionTypeAndIterator.cs     |  20 +
 .../ArrayDelegateSerializer.cs                | 211 +++++
 .../CollectionDelegateSerializer.cs           | 414 +++++++++
 .../ReflectionSerializers/Delegates.cs        |  25 +
 .../DictionaryDelegateSerializer.cs           | 550 ++++++++++++
 .../IReflectionObjectSerializer.cs            |  19 +
 .../ObjectDelegateSerializer.AsyncDecoders.cs | 125 +++
 .../ObjectDelegateSerializer.Decoders.cs      | 137 +++
 .../ObjectDelegateSerializer.Encoders.cs      | 128 +++
 .../ObjectDelegateSerializer.cs               | 834 ++++++++++++++++++
 .../ReflectionSerializerBuilder.cs            |  12 +
 .../ReflectionSerializerThrow.cs              |  25 +
 .../ReflectionSerializer`1.cs                 | 113 +++
 .../ReflectionSerializer`2.cs                 | 126 ---
 19 files changed, 3531 insertions(+), 127 deletions(-)
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.tt
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndCount.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndIterator.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/Delegates.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/IReflectionObjectSerializer.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.AsyncDecoders.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Decoders.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Encoders.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerThrow.cs
 create mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs
 delete mode 100644 src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs

diff --git a/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj b/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
index 1f7897a73..da2a63db6 100644
--- a/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
+++ b/src/MsgPack.Serialization.Reflection/MsgPack.Serialization.Reflection.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
@@ -9,4 +9,23 @@
     <ProjectReference Include="..\MsgPack.Serialization\MsgPack.Serialization.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="Serialization\Internal\AsyncDecodeHelpers.Primitives.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>AsyncDecodeHelpers.Primitives.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Serialization\Internal\AsyncDecodeHelpers.Primitives.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>AsyncDecodeHelpers.Primitives.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
 </Project>
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.cs b/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.cs
new file mode 100644
index 000000000..8cc846f88
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.cs
@@ -0,0 +1,567 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	partial class AsyncDecodeHelpers
+	{
+		public static async ValueTask<SByte> DecodeSByteAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			SByte result;
+			while (!TryDecodeSByte(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeSByte(FormatDecoder decoder, ReadOnlyStreamSequence source, out SByte result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeSByte(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<SByte?> DecodeNullableSByteAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			SByte? result;
+			while (!TryDecodeNullableSByte(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableSByte(FormatDecoder decoder, ReadOnlyStreamSequence source, out SByte? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableSByte(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Int16> DecodeInt16Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Int16 result;
+			while (!TryDecodeInt16(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeInt16(FormatDecoder decoder, ReadOnlyStreamSequence source, out Int16 result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeInt16(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Int16?> DecodeNullableInt16Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Int16? result;
+			while (!TryDecodeNullableInt16(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableInt16(FormatDecoder decoder, ReadOnlyStreamSequence source, out Int16? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableInt16(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Int32> DecodeInt32Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Int32 result;
+			while (!TryDecodeInt32(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeInt32(FormatDecoder decoder, ReadOnlyStreamSequence source, out Int32 result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeInt32(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Int32?> DecodeNullableInt32Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Int32? result;
+			while (!TryDecodeNullableInt32(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableInt32(FormatDecoder decoder, ReadOnlyStreamSequence source, out Int32? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableInt32(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Int64> DecodeInt64Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Int64 result;
+			while (!TryDecodeInt64(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeInt64(FormatDecoder decoder, ReadOnlyStreamSequence source, out Int64 result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeInt64(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Int64?> DecodeNullableInt64Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Int64? result;
+			while (!TryDecodeNullableInt64(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableInt64(FormatDecoder decoder, ReadOnlyStreamSequence source, out Int64? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableInt64(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Byte> DecodeByteAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Byte result;
+			while (!TryDecodeByte(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeByte(FormatDecoder decoder, ReadOnlyStreamSequence source, out Byte result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeByte(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Byte?> DecodeNullableByteAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Byte? result;
+			while (!TryDecodeNullableByte(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableByte(FormatDecoder decoder, ReadOnlyStreamSequence source, out Byte? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableByte(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<UInt16> DecodeUInt16Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			UInt16 result;
+			while (!TryDecodeUInt16(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeUInt16(FormatDecoder decoder, ReadOnlyStreamSequence source, out UInt16 result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeUInt16(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<UInt16?> DecodeNullableUInt16Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			UInt16? result;
+			while (!TryDecodeNullableUInt16(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableUInt16(FormatDecoder decoder, ReadOnlyStreamSequence source, out UInt16? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableUInt16(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<UInt32> DecodeUInt32Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			UInt32 result;
+			while (!TryDecodeUInt32(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeUInt32(FormatDecoder decoder, ReadOnlyStreamSequence source, out UInt32 result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeUInt32(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<UInt32?> DecodeNullableUInt32Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			UInt32? result;
+			while (!TryDecodeNullableUInt32(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableUInt32(FormatDecoder decoder, ReadOnlyStreamSequence source, out UInt32? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableUInt32(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<UInt64> DecodeUInt64Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			UInt64 result;
+			while (!TryDecodeUInt64(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeUInt64(FormatDecoder decoder, ReadOnlyStreamSequence source, out UInt64 result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeUInt64(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<UInt64?> DecodeNullableUInt64Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			UInt64? result;
+			while (!TryDecodeNullableUInt64(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableUInt64(FormatDecoder decoder, ReadOnlyStreamSequence source, out UInt64? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableUInt64(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Boolean> DecodeBooleanAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Boolean result;
+			while (!TryDecodeBoolean(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeBoolean(FormatDecoder decoder, ReadOnlyStreamSequence source, out Boolean result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeBoolean(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Boolean?> DecodeNullableBooleanAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Boolean? result;
+			while (!TryDecodeNullableBoolean(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableBoolean(FormatDecoder decoder, ReadOnlyStreamSequence source, out Boolean? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableBoolean(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Single> DecodeSingleAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Single result;
+			while (!TryDecodeSingle(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeSingle(FormatDecoder decoder, ReadOnlyStreamSequence source, out Single result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeSingle(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Single?> DecodeNullableSingleAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Single? result;
+			while (!TryDecodeNullableSingle(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableSingle(FormatDecoder decoder, ReadOnlyStreamSequence source, out Single? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableSingle(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Double> DecodeDoubleAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Double result;
+			while (!TryDecodeDouble(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeDouble(FormatDecoder decoder, ReadOnlyStreamSequence source, out Double result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeDouble(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<Double?> DecodeNullableDoubleAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			Double? result;
+			while (!TryDecodeNullableDouble(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableDouble(FormatDecoder decoder, ReadOnlyStreamSequence source, out Double? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableDouble(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<String> DecodeStringAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			String result;
+			while (!TryDecodeString(decoder, source, encoding: null, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		public static async ValueTask<String> DecodeStringAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, Encoding? encoding, CancellationToken cancellationToken)
+		{
+			String result;
+			while (!TryDecodeString(decoder, source, encoding, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeString(FormatDecoder decoder, ReadOnlyStreamSequence source, Encoding? encoding, out String result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeString(ref reader, out requestHint, encoding, cancellationToken)!;
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<String?> DecodeNullableStringAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			String? result;
+			while (!TryDecodeNullableString(decoder, source, encoding: null, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		public static async ValueTask<String?> DecodeNullableStringAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, Encoding? encoding, CancellationToken cancellationToken)
+		{
+			String? result;
+			while (!TryDecodeNullableString(decoder, source, encoding, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableString(FormatDecoder decoder, ReadOnlyStreamSequence source, Encoding? encoding, out String? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableString(ref reader, out requestHint, encoding, cancellationToken);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<byte[]> DecodeBinaryAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			byte[] result;
+			while (!TryDecodeBinary(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeBinary(FormatDecoder decoder, ReadOnlyStreamSequence source, out byte[] result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeBinary(ref reader, out requestHint)!;
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<byte[]?> DecodeNullableBinaryAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			byte[]? result;
+			while (!TryDecodeNullableBinary(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNullableBinary(FormatDecoder decoder, ReadOnlyStreamSequence source, out byte[]? result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeNullableBinary(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.tt b/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.tt
new file mode 100644
index 000000000..0fb1e8a09
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.Primitives.tt
@@ -0,0 +1,87 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Reflection" #>
+<#@ import namespace="System.Reflection.Emit" #>
+<#@ output extension=".cs" #>
+<#
+var types =
+	new []
+	{
+		typeof(sbyte),
+		typeof(short),
+		typeof(int),
+		typeof(long),
+		typeof(byte),
+		typeof(ushort),
+		typeof(uint),
+		typeof(ulong),
+		typeof(bool),
+		typeof(float),
+		typeof(double),
+	}.Select(t => (Name: t.Name, Type: t.Name, IsReferenceType: false))
+	.Concat(
+		new []
+		{
+			(Name: "String", Type: "String", IsReferenceType: true),
+			(Name: "Binary", Type: "byte[]", IsReferenceType: true)
+		}
+	).ToArray();
+#>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	partial class AsyncDecodeHelpers
+	{
+<#
+foreach (var type in types)
+{
+	foreach (var isNullable in new [] { false, true })
+	{
+		var methodName = $"Decode{(isNullable ? "Nullable" : String.Empty)}{type.Name}";
+		var returnType = $"{type.Type}{(isNullable ? "?" : String.Empty)}";
+#>
+		public static async ValueTask<<#= returnType #>> <#= methodName #>Async(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			<#= returnType #> result;
+			while (!Try<#= methodName #>(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool Try<#= methodName #>(FormatDecoder decoder, ReadOnlyStreamSequence source, out <#= returnType #> result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.<#= methodName #>(ref reader, out requestHint)<#= (!isNullable && type.IsReferenceType) ? "!" : String.Empty #>;
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+<#
+	}
+}
+#>
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.cs b/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.cs
new file mode 100644
index 000000000..b38b22f28
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/Internal/AsyncDecodeHelpers.cs
@@ -0,0 +1,224 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	internal static partial class AsyncDecodeHelpers
+	{
+		public static async ValueTask<bool> TryDecodeNullAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			bool result;
+			while (!TryDecodeNull(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeNull(FormatDecoder decoder, ReadOnlyStreamSequence source, out bool result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.TryDecodeNull(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<int> DecodeArrayHeaderAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			int result;
+			while (!TryDecodeArrayHeader(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeArrayHeader(FormatDecoder decoder, ReadOnlyStreamSequence source, out int result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeArrayHeader(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<int> DecodeMapHeaderAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			int result;
+			while (!TryDecodeMapHeader(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeMapHeader(FormatDecoder decoder, ReadOnlyStreamSequence source, out int result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeArrayHeader(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<CollectionTypeAndCount> DecodeArrayOrMapHeaderAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			CollectionTypeAndCount result;
+			while (!TryDecodeArrayOrMapHeader(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeArrayOrMapHeader(FormatDecoder decoder, ReadOnlyStreamSequence source, out CollectionTypeAndCount result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			var type = decoder.DecodeArrayOrMapHeader(ref reader, out var itemsCount, out requestHint);
+			result = new CollectionTypeAndCount(type, itemsCount);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<CollectionItemIterator> DecodeArrayAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			CollectionItemIterator result;
+			while (!TryDecodeArray(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeArray(FormatDecoder decoder, ReadOnlyStreamSequence source, out CollectionItemIterator result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeArray(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<CollectionItemIterator> DecodeMapAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			CollectionItemIterator result;
+			while (!TryDecodeMap(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeMap(FormatDecoder decoder, ReadOnlyStreamSequence source, out CollectionItemIterator result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = decoder.DecodeArray(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<CollectionTypeAndIterator> DecodeArrayOrMapAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			CollectionTypeAndIterator result;
+			while (!TryDecodeArrayOrMap(decoder, source, out result, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static bool TryDecodeArrayOrMap(FormatDecoder decoder, ReadOnlyStreamSequence source, out CollectionTypeAndIterator result, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			var type = decoder.DecodeArrayOrMap(ref reader, out var iterator, out requestHint);
+			result = new CollectionTypeAndIterator(type, iterator);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask SkipAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CollectionContext collectionContext, CancellationToken cancellationToken)
+		{
+			while (!TrySkip(decoder, source, collectionContext, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+		}
+
+		private static bool TrySkip(FormatDecoder decoder, ReadOnlyStreamSequence source, CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			decoder.Skip(ref reader, collectionContext, out requestHint, cancellationToken);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask DrainAsync(this FormatDecoder decoder, ReadOnlyStreamSequence source, CollectionContext collectionContext, long itemsCount, CancellationToken cancellationToken)
+		{
+			while (!TryDrain(decoder, source, collectionContext, itemsCount, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+		}
+
+		private static bool TryDrain(FormatDecoder decoder, ReadOnlyStreamSequence source, CollectionContext collectionContext, long itemsCount, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			decoder.Drain(ref reader, collectionContext, itemsCount, out requestHint, cancellationToken);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask<bool> CollectionEndsAsync(this CollectionItemIterator iterator, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			bool result;
+			while (!TryCollectionEnds(iterator, source, out result, out var requestHint))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		private static bool TryCollectionEnds(CollectionItemIterator iterator, ReadOnlyStreamSequence source, out bool result, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = iterator.CollectionEnds(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+
+		public static async ValueTask DrainAsync(this CollectionItemIterator iterator, ReadOnlyStreamSequence source, CancellationToken cancellationToken)
+		{
+			while (!TryDrain(iterator, source, out var requestHint, cancellationToken))
+			{
+				await source.FetchAsync(requestHint, cancellationToken).ConfigureAwait(false);
+			}
+		}
+
+		private static bool TryDrain(CollectionItemIterator iterator, ReadOnlyStreamSequence source, out int requestHint, CancellationToken cancellationToken)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			iterator.Drain(ref reader, out requestHint);
+			source.Advance(reader.Consumed);
+			return requestHint == 0;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndCount.cs b/src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndCount.cs
new file mode 100644
index 000000000..0f444d866
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndCount.cs
@@ -0,0 +1,20 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	internal struct CollectionTypeAndCount
+	{
+		public CollectionType CollectionType { get; }
+		public int ItemsCount { get; }
+
+		public CollectionTypeAndCount(CollectionType collectionType, int itemsCount)
+		{
+			this.CollectionType = collectionType;
+			this.ItemsCount = itemsCount;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndIterator.cs b/src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndIterator.cs
new file mode 100644
index 000000000..7f5e4be9e
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/Internal/CollectionTypeAndIterator.cs
@@ -0,0 +1,20 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Internal
+{
+	internal struct CollectionTypeAndIterator
+	{
+		public CollectionType CollectionType { get; }
+		public CollectionItemIterator Iterator { get; }
+
+		public CollectionTypeAndIterator(CollectionType collectionType, CollectionItemIterator iterator)
+		{
+			this.CollectionType = collectionType;
+			this.Iterator = iterator;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs
new file mode 100644
index 000000000..aed418e19
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs
@@ -0,0 +1,211 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+using MsgPack.Serialization.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	/// <summary>
+	///		Specialized implementation of <see cref="IReflectionObjectSerializer"/> for arrays.
+	/// </summary>
+	internal sealed class ArrayDelegateSerializer : IReflectionObjectSerializer
+	{
+		private readonly Type _targetType;
+		private readonly bool _itemIsCollection;
+		private readonly Serialization _serializeItem;
+		private readonly Deserialization _deserializeItem;
+#if FEATURE_TAP
+		private readonly AsyncDeserialization _deserializeItemAsync;
+#endif // FEATURE_TAP
+
+		public ArrayDelegateSerializer(
+			Serialization serializeItem,
+			Deserialization deserializeItem,
+#if FEATURE_TAP
+			AsyncDeserialization deserializeItemAsync,
+#endif // FEATURE_TAP
+			Type targetType,
+			in CollectionTraits traits
+		)
+		{
+			this._targetType = targetType;
+			this._serializeItem = serializeItem;
+			this._deserializeItem = deserializeItem;
+#if FEATURE_TAP
+			this._deserializeItemAsync = deserializeItemAsync;
+#endif // FEATURE_TAP
+#warning TODO: allowNonCollectionEnumerableTypes
+			this._itemIsCollection = traits.ElementType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+		}
+
+		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
+		{
+			var encoder = context.Encoder;
+
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			var array = (object?[])obj;
+
+			encoder.EncodeArrayStart(array.Length, sink, context.CollectionContext);
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			for (var i = 0; i < array.Length; i++)
+			{
+				encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+				this._serializeItem(ref context, array[i], sink);
+				encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+
+				i++;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			encoder.EncodeArrayEnd(array.Length, sink, context.CollectionContext);
+		}
+
+		public object? Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var decoder = context.Decoder;
+			if (decoder.TryDecodeNull(ref source))
+			{
+				return null;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			object? result;
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				result = this.Deserialize(decoder.DecodeArrayHeader(ref source), ref context, ref source);
+			}
+			else
+			{
+				result = this.Deserialize(decoder, ref context, ref source);
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			return result;
+		}
+
+		private object?[] Deserialize(int itemsCount, ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var result = new object?[itemsCount];
+
+			for (var i = 0; i < itemsCount; i++)
+			{
+				result[i] = this._deserializeItem(ref context, ref source);
+			}
+
+			return result;
+		}
+
+		private object?[] Deserialize(FormatDecoder decoder, ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var result = new List<object?>();
+
+			var iterator = decoder.DecodeArray(ref source);
+			while (!iterator.CollectionEnds(ref source))
+			{
+				result.Add(this._deserializeItem(ref context, ref source));
+			}
+			iterator.Drain(ref source);
+
+			return result.ToArray();
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+			=> throw new NotSupportedException($"Array serializer does not support DeserializeTo.");
+
+#if FEATURE_TAP
+
+		public async ValueTask<object?> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var decoder = context.Decoder;
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			object? result;
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				result =
+					await this.DeserializeAsync(
+						await decoder.DecodeArrayHeaderAsync(source, context.CancellationToken).ConfigureAwait(false),
+						context,
+						source
+					).ConfigureAwait(false);
+			}
+			else
+			{
+				result = await this.DeserializeAsync(decoder, context, source).ConfigureAwait(false);
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			return result;
+		}
+
+		private async ValueTask<object?[]> DeserializeAsync(int itemsCount, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var result = new object?[itemsCount];
+
+			for (var i = 0; i < itemsCount; i++)
+			{
+				result[i] = await this._deserializeItemAsync(context, source).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		private async ValueTask<object?[]> DeserializeAsync(FormatDecoder decoder, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var result = new List<object?>();
+
+			var iterator = await decoder.DecodeArrayAsync(source, context.CancellationToken).ConfigureAwait(false);
+			while (!await iterator.CollectionEndsAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				result.Add(await this._deserializeItemAsync(context, source).ConfigureAwait(false));
+			}
+			await iterator.DrainAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			return result.ToArray();
+		}
+
+		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(this._targetType);
+			// never
+			return default;
+		}
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs
new file mode 100644
index 000000000..cf9f6fd32
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs
@@ -0,0 +1,414 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+using MsgPack.Serialization.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	/// <summary>
+	///		Implements <see cref="IReflectionObjectSerializer"/> for <see cref="IEnumerable"/>, <see cref="IEnumerable{T}"/>, 
+	///		<see cref="ICollection"/>, <see cref="ICollection{T}"/>, <see cref="IReadOnlyCollection{T}"/>, <see cref="ISet{T}"/>, 
+	///		<see cref="IList"/>, <see cref="IList{T}"/>, and <see cref="IReadOnlyList{T}"/> except array.
+	/// </summary>
+	internal sealed class CollectionDelegateSerializer : IReflectionObjectSerializer
+	{
+		private readonly bool _itemIsCollection;
+		private readonly Func<object, int>? _getCount;
+		private readonly Func<object, IEnumerator> _getEnumerator;
+		private readonly Serialization _serializeItem;
+		private readonly Func<int, object>? _constructorWithCapacity;
+		private readonly Func<object>? _defaultConstructor;
+		private readonly Action<object, object?> _add;
+		private readonly Deserialization _deserializeItem;
+#if FEATURE_TAP
+		private readonly AsyncDeserialization _deserializeItemAsync;
+#endif // FEATURE_TAP
+
+		public CollectionDelegateSerializer(
+			Serialization serializeItem,
+			Deserialization deserializeItem,
+#if FEATURE_TAP
+			AsyncDeserialization deserializeItemAsync,
+#endif // FEATURE_TAP
+			Type targetType,
+			in CollectionTraits traits
+		)
+		{
+			var countPropertyGetter = traits.CountPropertyGetter!;
+			var getEnumeratorMethod = traits.GetEnumeratorMethod!;
+			var addMethod = traits.AddMethod!;
+			var constructorWithCapacity = traits.ConstructorWithCapacity;
+			var defaultConstructor = traits.DefaultConstructor;
+
+			this._getEnumerator = c => (IEnumerator)getEnumeratorMethod.Invoke(c, BindingFlags.DoNotWrapExceptions, null, null, null)!;
+			this._getCount = c => (int)countPropertyGetter.Invoke(c, BindingFlags.DoNotWrapExceptions, null, null, null)!;
+			this._add =
+				addMethod == null ?
+					new Action<object, object?>((c, i) => Throw.UndeserializableCollection(targetType)) :
+					new Action<object, object?>((c, i) => addMethod.Invoke(c, BindingFlags.DoNotWrapExceptions, null, new object?[] { i }, null));
+			this._constructorWithCapacity =
+				constructorWithCapacity == null ?
+					default(Func<int, object>) :
+					c => constructorWithCapacity!.Invoke(BindingFlags.DoNotWrapExceptions, new object?[] { c })!;
+			this._defaultConstructor = () => defaultConstructor!.Invoke(BindingFlags.DoNotWrapExceptions, null)!;
+			if (this._constructorWithCapacity == null && this._defaultConstructor == null)
+			{
+				Throw.NoConstructorForCollection(targetType);
+			}
+
+			this._serializeItem = serializeItem;
+			this._deserializeItem = deserializeItem;
+#if FEATURE_TAP
+			this._deserializeItemAsync = deserializeItemAsync;
+#endif // FEATURE_TAP
+
+#warning TODO: allowNonCollectionEnumerableTypes
+			this._itemIsCollection = traits.ElementType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+		}
+
+		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
+		{
+			var encoder = context.Encoder;
+
+			if (obj is null)
+			{
+				encoder.EncodeNull(sink);
+				return;
+			}
+
+			if (this._getCount != null)
+			{
+				this.SerializeCountable(ref context, obj, sink, this._getCount);
+			}
+			else
+			{
+				this.SerializeUncountable(ref context, obj, sink);
+			}
+		}
+
+		private void SerializeCountable(ref SerializationOperationContext context, object obj, IBufferWriter<byte> sink, Func<object, int> getCount)
+		{
+			var encoder = context.Encoder;
+
+			var count = getCount(obj);
+			var i = 0;
+			var enumerator = this._getEnumerator(obj);
+			try
+			{
+				encoder.EncodeArrayStart(count, sink, context.CollectionContext);
+
+				if (this._itemIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				while (enumerator.MoveNext())
+				{
+					encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+					this._serializeItem(ref context, enumerator.Current, sink);
+					encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+					i++;
+				}
+
+				if (this._itemIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				encoder.EncodeArrayEnd(count, sink, context.CollectionContext);
+			}
+			finally
+			{
+				if (enumerator is IDisposable disposable)
+				{
+					disposable.Dispose();
+				}
+			}
+		}
+
+		private void SerializeUncountable(ref SerializationOperationContext context, object obj, IBufferWriter<byte> sink)
+		{
+			var encoder = context.Encoder;
+
+			var asList = new List<object?>();
+			var enumerator = this._getEnumerator(obj);
+			try
+			{
+				while (enumerator.MoveNext())
+				{
+					asList.Add(enumerator.Current);
+				}
+			}
+			finally
+			{
+				if (enumerator is IDisposable disposable)
+				{
+					disposable.Dispose();
+				}
+			}
+
+			var i = 0;
+			encoder.EncodeArrayStart(asList.Count, sink, context.CollectionContext);
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			foreach (var item in asList)
+			{
+				encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+				this._serializeItem(ref context, item, sink);
+				encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+				i++;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			encoder.EncodeArrayEnd(asList.Count, sink, context.CollectionContext);
+		}
+
+		public object? Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var decoder = context.Decoder;
+			if (decoder.TryDecodeNull(ref source))
+			{
+				return null;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			object? result;
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				result = this.Deserialize(decoder.DecodeArrayHeader(ref source), ref context, ref source);
+			}
+			else
+			{
+				result = this.Deserialize(decoder, ref context, ref source);
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			return result;
+		}
+
+		private object Deserialize(int itemsCount, ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var result = this._constructorWithCapacity?.Invoke(itemsCount) ?? this._defaultConstructor!();
+
+			for (var i = 0; i < itemsCount; i++)
+			{
+				this._add(result, this._deserializeItem(ref context, ref source));
+			}
+
+			return result;
+		}
+
+		private object Deserialize(FormatDecoder decoder, ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var result = this._defaultConstructor?.Invoke() ?? this._constructorWithCapacity!(0);
+
+			var iterator = decoder.DecodeArray(ref source);
+			while (!iterator.CollectionEnds(ref source))
+			{
+				this._add(result, this._deserializeItem(ref context, ref source));
+			}
+			iterator.Drain(ref source);
+
+			return result;
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			var decoder = context.Decoder;
+			if (decoder.TryDecodeNull(ref source))
+			{
+				return false;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				this.DeserializeTo(decoder.DecodeArrayHeader(ref source), ref context, ref source, obj);
+			}
+			else
+			{
+				this.DeserializeTo(decoder, ref context, ref source, obj);
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			return true;
+		}
+
+		private void DeserializeTo(int itemsCount, ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			for (var i = 0; i < itemsCount; i++)
+			{
+				this._add(obj, this._deserializeItem(ref context, ref source));
+			}
+		}
+
+		private void DeserializeTo(FormatDecoder decoder, ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			var iterator = decoder.DecodeArray(ref source);
+			while (!iterator.CollectionEnds(ref source))
+			{
+				this._add(obj, this._deserializeItem(ref context, ref source));
+			}
+			iterator.Drain(ref source);
+		}
+
+#if FEATURE_TAP
+
+		public async ValueTask<object?> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var decoder = context.Decoder;
+
+			if (await decoder.TryDecodeNullAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				return null;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			object? result;
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				result =
+					await this.DeserializeAsync(
+						await decoder.DecodeArrayHeaderAsync(source, context.CancellationToken).ConfigureAwait(false),
+						context,
+						source
+					).ConfigureAwait(false);
+			}
+			else
+			{
+				result = await this.DeserializeAsync(decoder, context, source).ConfigureAwait(false);
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			return result;
+		}
+
+		private async ValueTask<object?> DeserializeAsync(int itemsCount, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var result = this._constructorWithCapacity?.Invoke(itemsCount) ?? this._defaultConstructor!.Invoke();
+
+			for (var i = 0; i < itemsCount; i++)
+			{
+				this._add(result, await this._deserializeItemAsync(context, source).ConfigureAwait(false));
+			}
+
+			return result;
+		}
+
+		private async ValueTask<object?> DeserializeAsync(FormatDecoder decoder, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var result = this._defaultConstructor?.Invoke() ?? this._constructorWithCapacity!.Invoke(0);
+
+			var iterator = await decoder.DecodeArrayAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			while (!await iterator.CollectionEndsAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				this._add(result, await this._deserializeItemAsync(context, source).ConfigureAwait(false));
+			}
+
+			await iterator.DrainAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			return result;
+		}
+
+		public async ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			var decoder = context.Decoder;
+
+			if (await decoder.TryDecodeNullAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				return false;
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.IncrementDepth();
+			}
+
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				await this.DeserializeToAsync(
+					await decoder.DecodeArrayHeaderAsync(source, context.CancellationToken).ConfigureAwait(false),
+					context,
+					source,
+					obj
+				).ConfigureAwait(false);
+			}
+			else
+			{
+				await this.DeserializeToAsync(decoder, context, source, obj).ConfigureAwait(false);
+			}
+
+			if (this._itemIsCollection)
+			{
+				context.DecrementDepth();
+			}
+
+			return true;
+		}
+
+		private async ValueTask DeserializeToAsync(int itemsCount, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			for (var i = 0; i < itemsCount; i++)
+			{
+				this._add(obj, await this._deserializeItemAsync(context, source).ConfigureAwait(false));
+			}
+		}
+
+		private async ValueTask DeserializeToAsync(FormatDecoder decoder, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			var result = this._defaultConstructor?.Invoke() ?? this._constructorWithCapacity!.Invoke(0);
+
+			var iterator = await decoder.DecodeArrayAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			while (!await iterator.CollectionEndsAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				this._add(result, await this._deserializeItemAsync(context, source).ConfigureAwait(false));
+			}
+
+			await iterator.DrainAsync(source, context.CancellationToken).ConfigureAwait(false);
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/Delegates.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/Delegates.cs
new file mode 100644
index 000000000..6445e39fe
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/Delegates.cs
@@ -0,0 +1,25 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal delegate void Serialization(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink);
+	internal delegate object? Deserialization(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+	internal delegate ValueTask<object?> AsyncDeserialization(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source);
+	internal delegate bool DeserializingFill(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj);
+	internal delegate ValueTask<bool> AsyncDeserializingFill(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj);
+
+	internal delegate object? PrimitiveDecoder(FormatDecoder decoder, ref SequenceReader<byte> source);
+	internal delegate object? StringDecoder(FormatDecoder decoder, ref SequenceReader<byte> source, Encoding? encoding, CancellationToken cancellationToken);
+	internal delegate object? BinaryDecoder(FormatDecoder decoder, ref SequenceReader<byte> source, CancellationToken cancellationToken);
+	internal delegate ValueTask<object?> AsyncPrimitiveDecoder(FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken);
+	internal delegate ValueTask<object?> AsyncStringDecoder(FormatDecoder decoder, ReadOnlyStreamSequence source, Encoding? encoding, CancellationToken cancellationToken);
+	internal delegate ValueTask<object?> AsyncBinaryDecoder(FormatDecoder decoder, ReadOnlyStreamSequence source, CancellationToken cancellationToken);
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs
new file mode 100644
index 000000000..a6ca895d2
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs
@@ -0,0 +1,550 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+using MsgPack.Serialization.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	/// <summary>
+	///		Implements <see cref="IReflectionObjectSerializer"/> for <see cref="IDictionary"/>, <see cref="IDictionary{TKey, TValue}"/>, and <see cref="IReadOnlyDictionary{TKey, TValue}"/>.
+	/// </summary>
+	internal sealed class DictionaryDelegateSerializer : IReflectionObjectSerializer
+	{
+		private readonly bool _keyIsCollection;
+		private readonly bool _valueIsCollection;
+		private readonly Func<object, int> _getCount;
+		private readonly Func<object, IEnumerator> _getEnumerator;
+		private readonly Func<object, object> _getKey;
+		private readonly Func<object, object> _getValue;
+		private readonly Serialization _serializeKey;
+		private readonly Serialization _serializeValue;
+		private readonly Func<int, object>? _constructorWithCapacity;
+		private readonly Func<object>? _defaultConstructor;
+		private readonly Action<object, object?, object?> _add;
+		private readonly Deserialization _deserializeKey;
+		private readonly Deserialization _deserializeValue;
+#if FEATURE_TAP
+		private readonly AsyncDeserialization _deserializeKeyAsync;
+		private readonly AsyncDeserialization _deserializeValueAsync;
+#endif // FEATURE_TAP
+
+		public DictionaryDelegateSerializer(
+			Serialization serializeKey,
+			Serialization serializeValue,
+			Deserialization deserializeKey,
+			Deserialization deserializeValue,
+#if FEATURE_TAP
+			AsyncDeserialization deserializeKeyAsync,
+			AsyncDeserialization deserializeValueAsync,
+#endif // FEATURE_TAP
+			Type targetType,
+			in CollectionTraits traits
+		)
+		{
+			var countPropertyGetter = traits.CountPropertyGetter!;
+			var getEnumeratorMethod = traits.GetEnumeratorMethod!;
+			var addMethod = traits.AddMethod;
+			var constructorWithCapacity = traits.ConstructorWithCapacity;
+			var defaultConstructor = traits.DefaultConstructor;
+
+			var keyPropertyGetter = traits.ElementType!.GetProperty("Key")!.GetGetMethod()!;
+			var valuePropertyGetter = traits.ElementType!.GetProperty("Value")!.GetGetMethod()!;
+
+			this._getEnumerator = c => (IEnumerator)getEnumeratorMethod.Invoke(c, BindingFlags.DoNotWrapExceptions, null, null, null)!;
+			this._getCount = c => (int)countPropertyGetter.Invoke(c, BindingFlags.DoNotWrapExceptions, null, null, null)!;
+			this._getKey = e => (string)keyPropertyGetter.Invoke(e, BindingFlags.DoNotWrapExceptions, null, null, null)!;
+			this._getValue = e => valuePropertyGetter.Invoke(e, BindingFlags.DoNotWrapExceptions, null, null, null)!;
+
+			this._add =
+				addMethod == null ?
+					new Action<object, object?, object?>((c, k, v) => Throw.UndeserializableCollection(targetType)) :
+					new Action<object, object?, object?>((c, k, v) => addMethod.Invoke(c, BindingFlags.DoNotWrapExceptions, null, new object?[] { k, v }, null));
+			var (keyType, valueType) = traits.GetKeyValueType();
+
+			this._constructorWithCapacity =
+				constructorWithCapacity == null ?
+					default(Func<int, object>) :
+					c => constructorWithCapacity!.Invoke(BindingFlags.DoNotWrapExceptions, new object?[] { c })!;
+			this._defaultConstructor = () => defaultConstructor!.Invoke(BindingFlags.DoNotWrapExceptions, null)!;
+			if (this._constructorWithCapacity == null && this._defaultConstructor == null)
+			{
+				Throw.NoConstructorForCollection(targetType);
+			}
+
+			this._serializeKey = serializeKey;
+			this._serializeValue = serializeValue;
+
+			this._deserializeKey = deserializeKey;
+			this._deserializeValue = deserializeValue;
+#if FEATURE_TAP
+			this._deserializeKeyAsync = deserializeKeyAsync;
+			this._deserializeValueAsync = deserializeValueAsync;
+#endif // FEATURE_TAP
+
+#warning TODO: allowNonCollectionEnumerableTypes
+			this._keyIsCollection = keyType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+			this._valueIsCollection = valueType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+		}
+
+		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
+		{
+			var encoder = context.Encoder;
+			if (obj is null)
+			{
+				encoder.EncodeNull(sink);
+				return;
+			}
+
+			var count = this._getCount(obj);
+			var i = 0;
+			var enumerator = this._getEnumerator(obj);
+			try
+			{
+				encoder.EncodeMapStart(count, sink, context.CollectionContext);
+				while (enumerator.MoveNext())
+				{
+					var entry = enumerator.Current;
+					var key = this._getKey(entry!);
+					var value = this._getValue(entry!);
+
+					encoder.EncodeMapKeyStart(i, sink, context.CollectionContext);
+
+					if (this._keyIsCollection)
+					{
+						context.IncrementDepth();
+					}
+
+					this._serializeKey(ref context, key, sink);
+
+					if (this._keyIsCollection)
+					{
+						context.DecrementDepth();
+					}
+
+					encoder.EncodeMapKeyEnd(i, sink, context.CollectionContext);
+
+					encoder.EncodeMapValueStart(i, sink, context.CollectionContext);
+
+					if (this._valueIsCollection)
+					{
+						context.IncrementDepth();
+					}
+
+					this._serializeValue(ref context, key, sink);
+
+					if (this._valueIsCollection)
+					{
+						context.DecrementDepth();
+					}
+
+					encoder.EncodeMapValueEnd(i, sink, context.CollectionContext);
+
+					i++;
+				}
+				encoder.EncodeMapEnd(count, sink, context.CollectionContext);
+			}
+			finally
+			{
+				if (enumerator is IDisposable disposable)
+				{
+					disposable.Dispose();
+				}
+			}
+		}
+
+		public object? Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var decoder = context.Decoder;
+			if (decoder.TryDecodeNull(ref source))
+			{
+				return null;
+			}
+
+			object? result;
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				result = this.Deserialize(decoder.DecodeArrayHeader(ref source), ref context, ref source);
+			}
+			else
+			{
+				result = this.Deserialize(decoder, ref context, ref source);
+			}
+
+			return result;
+		}
+
+		private object Deserialize(int itemsCount, ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var result = this._constructorWithCapacity?.Invoke(itemsCount) ?? this._defaultConstructor!();
+
+			for (var i = 0; i < itemsCount; i++)
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = this._deserializeKey(ref context, ref source);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = this._deserializeValue(ref context, ref source);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(result, key, value);
+			}
+
+			return result;
+		}
+
+		private object Deserialize(FormatDecoder decoder, ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var result = this._defaultConstructor?.Invoke() ?? this._constructorWithCapacity!(0);
+
+			var iterator = decoder.DecodeArray(ref source);
+
+			while (!iterator.CollectionEnds(ref source))
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = this._deserializeKey(ref context, ref source);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = this._deserializeValue(ref context, ref source);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(result, key, value);
+			}
+
+			iterator.Drain(ref source);
+
+			return result;
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			var decoder = context.Decoder;
+			if (decoder.TryDecodeNull(ref source))
+			{
+				return false;
+			}
+
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				this.DeserializeTo(decoder.DecodeArrayHeader(ref source), ref context, ref source, obj);
+			}
+			else
+			{
+				this.DeserializeTo(decoder, ref context, ref source, obj);
+			}
+
+			return true;
+		}
+
+		private void DeserializeTo(int itemsCount, ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			for (var i = 0; i < itemsCount; i++)
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = this._deserializeKey(ref context, ref source);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = this._deserializeValue(ref context, ref source);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(obj, key, value);
+			}
+		}
+
+		private void DeserializeTo(FormatDecoder decoder, ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			var iterator = decoder.DecodeArray(ref source);
+			while (!iterator.CollectionEnds(ref source))
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = this._deserializeKey(ref context, ref source);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = this._deserializeValue(ref context, ref source);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(obj, key, value);
+			}
+
+			iterator.Drain(ref source);
+		}
+
+#if FEATURE_TAP
+
+		public async ValueTask<object?> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var decoder = context.Decoder;
+
+			if (await decoder.TryDecodeNullAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				return null;
+			}
+
+			object? result;
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				result =
+					await this.DeserializeAsync(
+						await decoder.DecodeArrayHeaderAsync(source, context.CancellationToken).ConfigureAwait(false),
+						context,
+						source
+					).ConfigureAwait(false);
+			}
+			else
+			{
+				result = await this.DeserializeAsync(decoder, context, source).ConfigureAwait(false);
+			}
+
+			return result;
+		}
+
+		private async ValueTask<object?> DeserializeAsync(int itemsCount, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var result = this._constructorWithCapacity?.Invoke(itemsCount) ?? this._defaultConstructor!.Invoke();
+
+			for (var i = 0; i < itemsCount; i++)
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = await this._deserializeKeyAsync(context, source).ConfigureAwait(false);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = await this._deserializeValueAsync(context, source).ConfigureAwait(false);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(result, key, value);
+			}
+
+			return result;
+		}
+
+		private async ValueTask<object?> DeserializeAsync(FormatDecoder decoder, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var result = this._defaultConstructor?.Invoke() ?? this._constructorWithCapacity!.Invoke(0);
+
+			var iterator = await decoder.DecodeArrayAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			while (!await iterator.CollectionEndsAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = await this._deserializeKeyAsync(context, source).ConfigureAwait(false);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = await this._deserializeValueAsync(context, source).ConfigureAwait(false);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(result, key, value);
+			}
+
+			await iterator.DrainAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			return result;
+		}
+
+		public async ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			var decoder = context.Decoder;
+
+			if (await decoder.TryDecodeNullAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				return false;
+			}
+
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				await this.DeserializeToAsync(
+					await decoder.DecodeArrayHeaderAsync(source, context.CancellationToken).ConfigureAwait(false),
+					context,
+					source,
+					obj
+				).ConfigureAwait(false);
+			}
+			else
+			{
+				await this.DeserializeToAsync(decoder, context, source, obj).ConfigureAwait(false);
+			}
+
+			return true;
+		}
+
+		private async ValueTask DeserializeToAsync(int itemsCount, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			for (var i = 0; i < itemsCount; i++)
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = await this._deserializeKeyAsync(context, source).ConfigureAwait(false);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = await this._deserializeValueAsync(context, source).ConfigureAwait(false);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(obj, key, value);
+			}
+		}
+
+		private async ValueTask DeserializeToAsync(FormatDecoder decoder, AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			var result = this._defaultConstructor?.Invoke() ?? this._constructorWithCapacity!.Invoke(0);
+
+			var iterator = await decoder.DecodeArrayAsync(source, context.CancellationToken).ConfigureAwait(false);
+
+			while (!await iterator.CollectionEndsAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				if (this._keyIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var key = await this._deserializeKeyAsync(context, source).ConfigureAwait(false);
+
+				if (this._keyIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				if (this._valueIsCollection)
+				{
+					context.IncrementDepth();
+				}
+
+				var value = await this._deserializeValueAsync(context, source).ConfigureAwait(false);
+
+				if (this._valueIsCollection)
+				{
+					context.DecrementDepth();
+				}
+
+				this._add(result, key, value);
+			}
+
+			await iterator.DrainAsync(source, context.CancellationToken).ConfigureAwait(false);
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/IReflectionObjectSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/IReflectionObjectSerializer.cs
new file mode 100644
index 000000000..25144c7ae
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/IReflectionObjectSerializer.cs
@@ -0,0 +1,19 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal interface IReflectionObjectSerializer
+	{
+		void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink);
+		object? Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+		bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj);
+		ValueTask<object?> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source);
+		ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj);
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.AsyncDecoders.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.AsyncDecoders.cs
new file mode 100644
index 000000000..5ff4c8169
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.AsyncDecoders.cs
@@ -0,0 +1,125 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+using MsgPack.Serialization.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal partial class ObjectDelegateSerializer
+	{
+		private static readonly AsyncPrimitiveDecoder DecodeSByteNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeSByteAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeSByteNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableSByteAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeInt16NonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeInt16Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeInt16NullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableInt16Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeInt32NonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeInt32Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeInt32NullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableInt32Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeInt64NonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeInt64Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeInt64NullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableInt64Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeByteNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeByteAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeByteNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableByteAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeUInt16NonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeUInt16Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeUInt16NullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableUInt16Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeUInt32NonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeUInt32Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeUInt32NullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableUInt32Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeUInt64NonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeUInt64Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeUInt64NullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableUInt64Async(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeBooleanNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeBooleanAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeBooleanNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableBooleanAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeSingleNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeSingleAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeSingleNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableSingleAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeDoubleNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeDoubleAsync(s, c).ConfigureAwait(false);
+		private static readonly AsyncPrimitiveDecoder DecodeDoubleNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableDoubleAsync(s, c).ConfigureAwait(false);
+
+		// Also for IEnumerable<char>
+		private static readonly AsyncStringDecoder DecodeStringNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => await d.DecodeStringAsync(s, e, c).ConfigureAwait(false);
+
+		// Also for IEnumerable<char>?
+		private static readonly AsyncStringDecoder DecodeStringNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => await d.DecodeNullableStringAsync(s, e, c).ConfigureAwait(false);
+
+		private static readonly AsyncStringDecoder DecodeStringBuilderNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => AsStringBuilder(await d.DecodeStringAsync(s, e, c).ConfigureAwait(false));
+
+		private static readonly AsyncStringDecoder DecodeStringBuilderNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => AsStringBuilder(await d.DecodeNullableStringAsync(s, e, c).ConfigureAwait(false));
+
+		private static readonly AsyncStringDecoder DecodeCharArrayNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => (await d.DecodeStringAsync(s, e, c).ConfigureAwait(false)).ToCharArray();
+
+		private static readonly AsyncStringDecoder DecodeCharArrayNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => (await d.DecodeNullableStringAsync(s, e, c).ConfigureAwait(false))?.ToCharArray();
+
+		private static readonly AsyncStringDecoder DecodeReadOnlyMemoryOfCharNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => (await d.DecodeStringAsync(s, e, c).ConfigureAwait(false)).AsMemory();
+
+		private static readonly AsyncStringDecoder DecodeReadOnlyMemoryOfCharNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => (await d.DecodeNullableStringAsync(s, e, c).ConfigureAwait(false))?.AsMemory();
+
+		private static readonly AsyncStringDecoder DecodeMemoryOfCharNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => (await d.DecodeStringAsync(s, e, c).ConfigureAwait(false)).ToCharArray().AsMemory();
+
+		private static readonly AsyncStringDecoder DecodeMemoryOfCharNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => (await d.DecodeNullableStringAsync(s, e, c).ConfigureAwait(false))?.ToCharArray()?.AsMemory();
+
+		private static readonly AsyncStringDecoder DecodeReadOnlySequenceOfCharNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => new ReadOnlySequence<char>((await d.DecodeStringAsync(s, e, c).ConfigureAwait(false)).AsMemory());
+
+		private static readonly AsyncStringDecoder DecodeReadOnlySequenceOfCharNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, Encoding? e, CancellationToken c) => AsSequence(await d.DecodeNullableStringAsync(s, e, c).ConfigureAwait(false));
+
+		private static readonly AsyncBinaryDecoder DecodeByteArrayNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeBinaryAsync(s, c).ConfigureAwait(false);
+
+		private static readonly AsyncBinaryDecoder DecodeByteArrayNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => await d.DecodeNullableBinaryAsync(s, c).ConfigureAwait(false);
+
+		private static readonly AsyncBinaryDecoder DecodeReadOnlyMemoryOfByteNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => AsReadOnlyMemory(await d.DecodeBinaryAsync(s, c).ConfigureAwait(false));
+
+		private static readonly AsyncBinaryDecoder DecodeReadOnlyMemoryOfByteNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => AsReadOnlyMemory(await d.DecodeNullableBinaryAsync(s, c).ConfigureAwait(false));
+
+		private static readonly AsyncBinaryDecoder DecodeMemoryOfByteNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => (await d.DecodeBinaryAsync(s, c).ConfigureAwait(false)).AsMemory();
+
+		private static readonly AsyncBinaryDecoder DecodeMemoryOfByteNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => (await d.DecodeNullableBinaryAsync(s, c).ConfigureAwait(false))?.AsMemory();
+
+		private static readonly AsyncBinaryDecoder DecodeReadOnlySequenceOfByteNonNullAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => new ReadOnlySequence<byte>(await d.DecodeBinaryAsync(s, c).ConfigureAwait(false));
+
+		private static readonly AsyncBinaryDecoder DecodeReadOnlySequenceOfByteNullableAsync =
+			async (FormatDecoder d, ReadOnlyStreamSequence s, CancellationToken c) => AsSequence(await d.DecodeNullableBinaryAsync(s, c).ConfigureAwait(false));
+
+		// Span/ReadOnlySpan is not supported.
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Decoders.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Decoders.cs
new file mode 100644
index 000000000..9092aec07
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Decoders.cs
@@ -0,0 +1,137 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal partial class ObjectDelegateSerializer
+	{
+		private static readonly PrimitiveDecoder DecodeSByteNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeSByte(ref s);
+		private static readonly PrimitiveDecoder DecodeSByteNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableSByte(ref s);
+		private static readonly PrimitiveDecoder DecodeInt16NonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeInt16(ref s);
+		private static readonly PrimitiveDecoder DecodeInt16Nullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableInt16(ref s);
+		private static readonly PrimitiveDecoder DecodeInt32NonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeInt32(ref s);
+		private static readonly PrimitiveDecoder DecodeInt32Nullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableInt32(ref s);
+		private static readonly PrimitiveDecoder DecodeInt64NonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeInt64(ref s);
+		private static readonly PrimitiveDecoder DecodeInt64Nullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableInt64(ref s);
+		private static readonly PrimitiveDecoder DecodeByteNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeByte(ref s);
+		private static readonly PrimitiveDecoder DecodeByteNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableByte(ref s);
+		private static readonly PrimitiveDecoder DecodeUInt16NonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeUInt16(ref s);
+		private static readonly PrimitiveDecoder DecodeUInt16Nullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableUInt16(ref s);
+		private static readonly PrimitiveDecoder DecodeUInt32NonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeUInt32(ref s);
+		private static readonly PrimitiveDecoder DecodeUInt32Nullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableUInt32(ref s);
+		private static readonly PrimitiveDecoder DecodeUInt64NonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeUInt64(ref s);
+		private static readonly PrimitiveDecoder DecodeUInt64Nullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableUInt64(ref s);
+		private static readonly PrimitiveDecoder DecodeBooleanNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeBoolean(ref s);
+		private static readonly PrimitiveDecoder DecodeBooleanNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableBoolean(ref s);
+		private static readonly PrimitiveDecoder DecodeSingleNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeSingle(ref s);
+		private static readonly PrimitiveDecoder DecodeSingleNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableSingle(ref s);
+		private static readonly PrimitiveDecoder DecodeDoubleNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeDouble(ref s);
+		private static readonly PrimitiveDecoder DecodeDoubleNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s) => d.DecodeNullableDouble(ref s);
+
+		// Also for IEnumerable<char>
+		private static readonly StringDecoder DecodeStringNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeString(ref s, e, c);
+
+		// Also for IEnumerable<char>?
+		private static readonly StringDecoder DecodeStringNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeNullableString(ref s, e, c);
+
+		private static readonly StringDecoder DecodeStringBuilderNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => AsStringBuilder(d.DecodeString(ref s, e, c));
+
+		private static readonly StringDecoder DecodeStringBuilderNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => AsStringBuilder(d.DecodeNullableString(ref s, e, c));
+
+		private static readonly StringDecoder DecodeCharArrayNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeString(ref s, e, c).ToCharArray();
+
+		private static readonly StringDecoder DecodeCharArrayNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeNullableString(ref s, e, c)?.ToCharArray();
+
+		private static readonly StringDecoder DecodeReadOnlyMemoryOfCharNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeString(ref s, e, c).AsMemory();
+
+		private static readonly StringDecoder DecodeReadOnlyMemoryOfCharNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeNullableString(ref s, e, c)?.AsMemory();
+
+		private static readonly StringDecoder DecodeMemoryOfCharNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeString(ref s, e, c).ToCharArray().AsMemory();
+
+		private static readonly StringDecoder DecodeMemoryOfCharNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => d.DecodeNullableString(ref s, e, c)?.ToCharArray()?.AsMemory();
+
+		private static readonly StringDecoder DecodeReadOnlySequenceOfCharNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => new ReadOnlySequence<char>(d.DecodeString(ref s, e, c).AsMemory());
+
+		private static readonly StringDecoder DecodeReadOnlySequenceOfCharNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, Encoding? e, CancellationToken c) => AsSequence(d.DecodeNullableString(ref s, e, c));
+
+		private static readonly BinaryDecoder DecodeByteArrayNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => d.DecodeBinary(ref s, c);
+
+		private static readonly BinaryDecoder DecodeByteArrayNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => d.DecodeNullableBinary(ref s, c);
+
+		private static readonly BinaryDecoder DecodeReadOnlyMemoryOfByteNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => AsReadOnlyMemory(d.DecodeBinary(ref s, c));
+
+		private static readonly BinaryDecoder DecodeReadOnlyMemoryOfByteNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => AsReadOnlyMemory(d.DecodeNullableBinary(ref s, c));
+
+		private static readonly BinaryDecoder DecodeMemoryOfByteNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => d.DecodeBinary(ref s, c).AsMemory();
+
+		private static readonly BinaryDecoder DecodeMemoryOfByteNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => d.DecodeNullableBinary(ref s, c)?.AsMemory();
+
+		private static readonly BinaryDecoder DecodeReadOnlySequenceOfByteNonNull =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => new ReadOnlySequence<byte>(d.DecodeBinary(ref s, c));
+
+		private static readonly BinaryDecoder DecodeReadOnlySequenceOfByteNullable =
+			(FormatDecoder d, ref SequenceReader<byte> s, CancellationToken c) => AsSequence(d.DecodeNullableBinary(ref s, c));
+
+		[return: NotNullIfNotNull("value")]
+		private static StringBuilder? AsStringBuilder(string? value) => value == null ? null : new StringBuilder(value);
+
+		[return: NotNullIfNotNull("value")]
+		private static ReadOnlyMemory<byte>? AsReadOnlyMemory(byte[]? value) => value == null ? default(ReadOnlyMemory<byte>?) : new ReadOnlyMemory<byte>(value);
+
+		[return: NotNullIfNotNull("value")]
+		private static ReadOnlySequence<char>? AsSequence(string? value) => value == null ? default(ReadOnlySequence<char>?) : new ReadOnlySequence<char>(value.AsMemory());
+
+		[return: NotNullIfNotNull("value")]
+		private static ReadOnlySequence<byte>? AsSequence(byte[]? value) => value == null ? default(ReadOnlySequence<byte>?) : new ReadOnlySequence<byte>(value);
+
+		// Span/ReadOnlySpan is not supported.
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Encoders.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Encoders.cs
new file mode 100644
index 000000000..1b7c36ff9
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.Encoders.cs
@@ -0,0 +1,128 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using MsgPack.Internal;
+
+using PrimitiveEncoder = System.Action<MsgPack.Internal.FormatEncoder, object?, System.Buffers.IBufferWriter<byte>>;
+using StringEncoder = System.Action<MsgPack.Internal.FormatEncoder, object?, System.Buffers.IBufferWriter<byte>, System.Text.Encoding?, System.Threading.CancellationToken>;
+using BinaryEncoder = System.Action<MsgPack.Internal.FormatEncoder, object?, System.Buffers.IBufferWriter<byte>, System.Threading.CancellationToken>;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal partial class ObjectDelegateSerializer
+	{
+		private static readonly PrimitiveEncoder EncodeInt32NonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeInt32((int)v!, s);
+		private static readonly PrimitiveEncoder EncodeInt32Nullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeInt32((int?)v, s);
+		private static readonly PrimitiveEncoder EncodeInt64NonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeInt64((long)v!, s);
+		private static readonly PrimitiveEncoder EncodeInt64Nullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeInt64((long?)v, s);
+		private static readonly PrimitiveEncoder EncodeUInt32NonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeUInt32((uint)v!, s);
+		private static readonly PrimitiveEncoder EncodeUInt32Nullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeUInt32((uint?)v, s);
+		private static readonly PrimitiveEncoder EncodeUInt64NonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeUInt64((ulong)v!, s);
+		private static readonly PrimitiveEncoder EncodeUInt64Nullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeUInt64((ulong?)v, s);
+		private static readonly PrimitiveEncoder EncodeBooleanNonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeBoolean((bool)v!, s);
+		private static readonly PrimitiveEncoder EncodeBooleanNullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeBoolean((bool?)v, s);
+		private static readonly PrimitiveEncoder EncodeSingleNonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeSingle((float)v!, s);
+		private static readonly PrimitiveEncoder EncodeSingleNullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeSingle((float?)v, s);
+		private static readonly PrimitiveEncoder EncodeDoubleNonNull =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeDouble((double)v!, s);
+		private static readonly PrimitiveEncoder EncodeDoubleNullable =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s) => e.EncodeDouble((double?)v, s);
+		private static readonly StringEncoder EncodeString =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s, Encoding? n, CancellationToken c) =>
+			{
+				if (v is null)
+				{
+					e.EncodeNull(s);
+					return;
+				}
+
+				if (v is string str)
+				{
+					e.EncodeString(str, s, n, c);
+				}
+				else if (v is StringBuilder builder)
+				{
+					e.EncodeString(builder, s, n, c);
+				}
+				else if (v is char[] array)
+				{
+					e.EncodeString(array, s, n, c);
+				}
+				else if (v is ReadOnlyMemory<char> rmemory)
+				{
+					e.EncodeString(rmemory.Span, s, n, c);
+				}
+				else if (v is Memory<char> memory)
+				{
+					e.EncodeString(memory.Span, s, n, c);
+				}
+				else if (v is ReadOnlySequence<char> sequence)
+				{
+					e.EncodeString(sequence, s, n, c);
+				}
+				else if (v is IEnumerable<char> collection)
+				{
+					e.EncodeString(collection.ToArray(), s, n, c);
+				}
+				else
+				{
+					Throw.UnexpectedStringType(v);
+				}
+			};
+
+		private static readonly BinaryEncoder EncodeBinary =
+			(FormatEncoder e, object? v, IBufferWriter<byte> s, CancellationToken c) =>
+			{
+				if (v is null)
+				{
+					e.EncodeNull(s);
+					return;
+				}
+
+				if (v is byte[] array)
+				{
+					e.EncodeBinary(array, s, c);
+				}
+				else if (v is ReadOnlyMemory<byte> rmemory)
+				{
+					e.EncodeBinary(rmemory.Span, s, c);
+				}
+				else if (v is Memory<byte> memory)
+				{
+					e.EncodeBinary(memory.Span, s, c);
+				}
+				else if (v is ReadOnlySequence<byte> sequence)
+				{
+					e.EncodeBinary(sequence, s, c);
+				}
+				else if (v is IEnumerable<byte> collection)
+				{
+					e.EncodeBinary(collection.ToArray(), s, c);
+				}
+				else
+				{
+					Throw.UnexpectedBinaryType(v);
+					sequence = default;
+				}
+			};
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs
new file mode 100644
index 000000000..e812a712d
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs
@@ -0,0 +1,834 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+using MsgPack.Serialization.Internal;
+
+using PrimitiveEncoder = System.Action<MsgPack.Internal.FormatEncoder, object?, System.Buffers.IBufferWriter<byte>>;
+using StringEncoder = System.Action<MsgPack.Internal.FormatEncoder, object?, System.Buffers.IBufferWriter<byte>, System.Text.Encoding?, System.Threading.CancellationToken>;
+using BinaryEncoder = System.Action<MsgPack.Internal.FormatEncoder, object?, System.Buffers.IBufferWriter<byte>, System.Threading.CancellationToken>;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	/// <summary>
+	///		Implements <see cref="IReflectionObjectSerializer"/> for non collection objects and tuples.
+	/// </summary>
+	internal sealed partial class ObjectDelegateSerializer : IReflectionObjectSerializer
+	{
+		private readonly IReadOnlyList<Delegate> _memberValueEncoders;
+		private readonly IReadOnlyList<Delegate> _memberValueDecoders;
+		private readonly IReadOnlyList<bool> _memberIsCollections;
+		private readonly IReadOnlyList<Func<object, object?>> _memberValueGetters;
+		private readonly IReadOnlyList<Action<object, object?>>? _memberValueSetters;
+		private readonly IReadOnlyDictionary<string, int> _memberIndexes;
+		private readonly SerializationTarget _target;
+		private readonly IReadOnlyList<Type>? _tupleTypes;
+#if FEATURE_TAP
+		private readonly IReadOnlyList<Delegate> _asyncMemberValueDecoders;
+#endif // FEATURE_TAP
+
+		// object
+		// tuple
+		// value tuple
+		public ObjectDelegateSerializer(ObjectSerializationContext context, SerializationTarget target)
+		{
+			this._target = target;
+			var isTuple = TupleItems.IsTuple(target.Type);
+			this._tupleTypes = isTuple ? null : TupleItems.CreateTupleTypeList(target.Type);
+			this._memberValueEncoders = CreateMemberValueEncoders(context, target.Members).ToList();
+			this._memberValueDecoders =
+				CreateMemberValueDecoders(
+					context,
+					target.Members,
+					hasDeserializationConstructor: target.DeserializationConstructor != null,
+					hasPriviledgedAccess: !context.Options.DisablePrivilegedAccess
+				).ToList();
+			this._memberIsCollections = DetermineWhetherIndividualMembersAreCollection(target.Members).ToList();
+			this._memberValueGetters = CreateMemberValueGetters(target.Members, this._tupleTypes).ToList();
+			this._memberValueSetters = this._tupleTypes == null ? null : CreateMemberValueSetters(target.Members).ToList();
+			this._memberIndexes = target.Members.Select((m, i) => (Name: m.MemberName, Index: i)).ToDictionary(x => x.Name ?? $"Item{x.Index}", x => x.Index);
+#if FEATURE_TAP
+			this._asyncMemberValueDecoders =
+				CreateAsyncMemberValueDecoders(
+					context,
+					target.Members,
+					hasDeserializationConstructor: target.DeserializationConstructor != null,
+					hasPriviledgedAccess: !context.Options.DisablePrivilegedAccess
+				).ToList();
+#endif // FEATURE_TAP
+		}
+
+		private static IEnumerable<Delegate> CreateMemberValueEncoders(ObjectSerializationContext context, IEnumerable<SerializingMember> members)
+		{
+			foreach (var member in members)
+			{
+				var type = member.Member.GetMemberValueType();
+				var memberInfo = member.Member;
+				yield return
+					type switch
+					{
+						var t when t == typeof(sbyte) || t == typeof(short) || t == typeof(int) => EncodeInt32NonNull,
+						var t when t == typeof(sbyte?) || t == typeof(short?) || t == typeof(int?) => EncodeInt32Nullable,
+						var t when t == typeof(long) => EncodeInt64NonNull,
+						var t when t == typeof(long?) => EncodeInt64Nullable,
+						var t when t == typeof(byte) || t == typeof(ushort) || t == typeof(uint) => EncodeUInt32NonNull,
+						var t when t == typeof(byte?) || t == typeof(ushort?) || t == typeof(uint?) => EncodeUInt32Nullable,
+						var t when t == typeof(ulong) => EncodeUInt64NonNull,
+						var t when t == typeof(ulong?) => EncodeUInt64Nullable,
+						var t when t == typeof(bool) => EncodeBooleanNonNull,
+						var t when t == typeof(bool?) => EncodeBooleanNullable,
+						var t when t == typeof(float) => EncodeSingleNonNull,
+						var t when t == typeof(float?) => EncodeSingleNullable,
+						var t when t == typeof(double) => EncodeDoubleNonNull,
+						var t when t == typeof(double?) => EncodeDoubleNullable,
+						var t
+							when t == typeof(string) || t == typeof(StringBuilder) || t == typeof(char[])
+							|| t == typeof(ReadOnlyMemory<char>) || t == typeof(Memory<char>) || t == typeof(ReadOnlySequence<char>) || t == typeof(IEnumerable<char>)
+								=> EncodeString,
+						var t when t == typeof(ReadOnlySpan<char>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var t when t == typeof(Span<char>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var t when t == typeof(byte[]) || t == typeof(ReadOnlyMemory<byte>) || t == typeof(Memory<byte>) || t == typeof(ReadOnlySequence<byte>) || t == typeof(IEnumerable<byte>)
+							=> EncodeBinary,
+						var t when t == typeof(ReadOnlySpan<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var t when t == typeof(Span<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+#warning TODO: PolymorphismSchema
+						_ => new Serialization(context.GetSerializer(type, null).SerializeObject)
+					};
+			}
+		}
+
+		private static IEnumerable<Delegate> CreateMemberValueDecoders(ObjectSerializationContext context, IEnumerable<SerializingMember> members, bool hasDeserializationConstructor, bool hasPriviledgedAccess)
+		{
+			foreach (var member in members)
+			{
+				var type = member.Member.GetMemberValueType();
+				var item = (Type: type, IsNullable: member.Member!.IsNullable());
+				var memberInfo = member.Member;
+				yield return
+					item switch
+					{
+						var x when x.Type == typeof(sbyte) => DecodeSByteNonNull,
+						var x when x.Type == typeof(short) => DecodeInt16NonNull,
+						var x when x.Type == typeof(int) => DecodeInt32NonNull,
+						var x when x.Type == typeof(sbyte?) => DecodeSByteNullable,
+						var x when x.Type == typeof(short?) => DecodeInt16Nullable,
+						var x when x.Type == typeof(int?) => DecodeInt32Nullable,
+						var x when x.Type == typeof(long) => DecodeInt64NonNull,
+						var x when x.Type == typeof(long?) => DecodeInt64Nullable,
+						var x when x.Type == typeof(byte) => DecodeByteNonNull,
+						var x when x.Type == typeof(ushort) => DecodeUInt16NonNull,
+						var x when x.Type == typeof(uint) => DecodeUInt32NonNull,
+						var x when x.Type == typeof(byte?) => DecodeByteNullable,
+						var x when x.Type == typeof(ushort?) => DecodeUInt16Nullable,
+						var x when x.Type == typeof(uint?) => DecodeUInt32Nullable,
+						var x when x.Type == typeof(ulong) => DecodeUInt64NonNull,
+						var x when x.Type == typeof(ulong?) => DecodeUInt64Nullable,
+						var x when x.Type == typeof(bool) => DecodeBooleanNonNull,
+						var x when x.Type == typeof(bool?) => DecodeBooleanNullable,
+						var x when x.Type == typeof(float) => DecodeSingleNonNull,
+						var x when x.Type == typeof(float?) => DecodeSingleNullable,
+						var x when x.Type == typeof(double) => DecodeDoubleNonNull,
+						var x when x.Type == typeof(double?) => DecodeDoubleNullable,
+						var x when (x.Type == typeof(string) || x.Type == typeof(IEnumerable<char>)) && !x.IsNullable => DecodeStringNonNull,
+						var x when (x.Type == typeof(string) || x.Type == typeof(IEnumerable<char>)) && x.IsNullable => DecodeStringNullable,
+						var x when x.Type == typeof(StringBuilder) && !x.IsNullable => DecodeStringBuilderNonNull,
+						var x when x.Type == typeof(StringBuilder) && x.IsNullable => DecodeStringBuilderNullable,
+						var x when x.Type == typeof(char[]) && !x.IsNullable => DecodeCharArrayNonNull,
+						var x when x.Type == typeof(char[]) && x.IsNullable => DecodeCharArrayNullable,
+						var x when x.Type == typeof(ReadOnlyMemory<char>) && !x.IsNullable => DecodeReadOnlyMemoryOfCharNonNull,
+						var x when x.Type == typeof(ReadOnlyMemory<char>) && x.IsNullable => DecodeReadOnlyMemoryOfCharNullable,
+						var x when x.Type == typeof(Memory<char>) && !x.IsNullable => DecodeMemoryOfCharNonNull,
+						var x when x.Type == typeof(Memory<char>) && x.IsNullable => DecodeMemoryOfCharNullable,
+						var x when x.Type == typeof(ReadOnlySequence<char>) && !x.IsNullable => DecodeReadOnlySequenceOfCharNonNull,
+						var x when x.Type == typeof(ReadOnlySequence<char>) && x.IsNullable => DecodeReadOnlySequenceOfCharNullable,
+						var x when x.Type == typeof(ReadOnlySpan<char>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var x when x.Type == typeof(Span<char>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) && !x.IsNullable => DecodeByteArrayNonNull,
+						var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) && x.IsNullable => DecodeByteArrayNullable,
+						var x when x.Type == typeof(ReadOnlyMemory<byte>) && !x.IsNullable => DecodeReadOnlyMemoryOfByteNonNull,
+						var x when x.Type == typeof(ReadOnlyMemory<byte>) && x.IsNullable => DecodeReadOnlyMemoryOfByteNullable,
+						var x when x.Type == typeof(Memory<byte>) && !x.IsNullable => DecodeMemoryOfCharNonNull,
+						var x when x.Type == typeof(Memory<byte>) && x.IsNullable => DecodeMemoryOfCharNullable,
+						var x when x.Type == typeof(ReadOnlySequence<byte>) && !x.IsNullable => DecodeReadOnlySequenceOfByteNonNull,
+						var x when x.Type == typeof(ReadOnlySequence<byte>) && x.IsNullable => DecodeReadOnlySequenceOfByteNullable,
+						var x when x.Type == typeof(ReadOnlySpan<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var x when x.Type == typeof(Span<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+#warning TODO: PolymorphismSchema
+						_ =>
+							hasDeserializationConstructor ?
+								new Deserialization(context.GetSerializer(type, null).DeserializeObject) :
+								memberInfo switch
+								{
+									PropertyInfo p =>
+										p switch
+										{
+											var pi when pi.GetSetMethod(nonPublic: hasPriviledgedAccess) != null => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
+											_ => new DeserializingFill(context.GetSerializer(type, null).DeserializeObjectTo),
+										},
+									FieldInfo f =>
+										f switch
+										{
+											var fi when !fi.IsInitOnly => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
+											_ => new DeserializingFill(context.GetSerializer(type, null).DeserializeObjectTo),
+										},
+									_ => ReflectionSerializerThrow.UnexpectedMemberType(memberInfo)
+								}
+					};
+			}
+		}
+
+#if FEATURE_TAP
+
+		private static IEnumerable<Delegate> CreateAsyncMemberValueDecoders(ObjectSerializationContext context, IEnumerable<SerializingMember> members, bool hasDeserializationConstructor, bool hasPriviledgedAccess)
+		{
+			foreach (var member in members)
+			{
+				var type = member.Member.GetMemberValueType();
+				var item = (Type: type, IsNullable: member.Member!.IsNullable());
+				var memberInfo = member.Member;
+				yield return
+					item switch
+					{
+						var x when x.Type == typeof(sbyte) => DecodeSByteNonNullAsync,
+						var x when x.Type == typeof(short) => DecodeInt16NonNullAsync,
+						var x when x.Type == typeof(int) => DecodeInt32NonNullAsync,
+						var x when x.Type == typeof(sbyte?) => DecodeSByteNullableAsync,
+						var x when x.Type == typeof(short?) => DecodeInt16NullableAsync,
+						var x when x.Type == typeof(int?) => DecodeInt32NullableAsync,
+						var x when x.Type == typeof(long) => DecodeInt64NonNullAsync,
+						var x when x.Type == typeof(long?) => DecodeInt64NullableAsync,
+						var x when x.Type == typeof(byte) => DecodeByteNonNullAsync,
+						var x when x.Type == typeof(ushort) => DecodeUInt16NonNullAsync,
+						var x when x.Type == typeof(uint) => DecodeUInt32NonNullAsync,
+						var x when x.Type == typeof(byte?) => DecodeByteNullableAsync,
+						var x when x.Type == typeof(ushort?) => DecodeUInt16NullableAsync,
+						var x when x.Type == typeof(uint?) => DecodeUInt32NullableAsync,
+						var x when x.Type == typeof(ulong) => DecodeUInt64NonNullAsync,
+						var x when x.Type == typeof(ulong?) => DecodeUInt64NullableAsync,
+						var x when x.Type == typeof(bool) => DecodeBooleanNonNullAsync,
+						var x when x.Type == typeof(bool?) => DecodeBooleanNullableAsync,
+						var x when x.Type == typeof(float) => DecodeSingleNonNullAsync,
+						var x when x.Type == typeof(float?) => DecodeSingleNullableAsync,
+						var x when x.Type == typeof(double) => DecodeDoubleNonNullAsync,
+						var x when x.Type == typeof(double?) => DecodeDoubleNullableAsync,
+						var x when (x.Type == typeof(string) || x.Type == typeof(IEnumerable<char>)) && !x.IsNullable => DecodeStringNonNullAsync,
+						var x when (x.Type == typeof(string) || x.Type == typeof(IEnumerable<char>)) && x.IsNullable => DecodeStringNullableAsync,
+						var x when x.Type == typeof(StringBuilder) && !x.IsNullable => DecodeStringBuilderNonNullAsync,
+						var x when x.Type == typeof(StringBuilder) && x.IsNullable => DecodeStringBuilderNullableAsync,
+						var x when x.Type == typeof(char[]) && !x.IsNullable => DecodeCharArrayNonNullAsync,
+						var x when x.Type == typeof(char[]) && x.IsNullable => DecodeCharArrayNullableAsync,
+						var x when x.Type == typeof(ReadOnlyMemory<char>) && !x.IsNullable => DecodeReadOnlyMemoryOfCharNonNullAsync,
+						var x when x.Type == typeof(ReadOnlyMemory<char>) && x.IsNullable => DecodeReadOnlyMemoryOfCharNullableAsync,
+						var x when x.Type == typeof(Memory<char>) && !x.IsNullable => DecodeMemoryOfCharNonNullAsync,
+						var x when x.Type == typeof(Memory<char>) && x.IsNullable => DecodeMemoryOfCharNullableAsync,
+						var x when x.Type == typeof(ReadOnlySequence<char>) && !x.IsNullable => DecodeReadOnlySequenceOfCharNonNullAsync,
+						var x when x.Type == typeof(ReadOnlySequence<char>) && x.IsNullable => DecodeReadOnlySequenceOfCharNullableAsync,
+						var x when x.Type == typeof(ReadOnlySpan<char>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var x when x.Type == typeof(Span<char>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) && !x.IsNullable => DecodeByteArrayNonNullAsync,
+						var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) && x.IsNullable => DecodeByteArrayNullableAsync,
+						var x when x.Type == typeof(ReadOnlyMemory<byte>) && !x.IsNullable => DecodeReadOnlyMemoryOfByteNonNullAsync,
+						var x when x.Type == typeof(ReadOnlyMemory<byte>) && x.IsNullable => DecodeReadOnlyMemoryOfByteNullableAsync,
+						var x when x.Type == typeof(Memory<byte>) && !x.IsNullable => DecodeMemoryOfCharNonNullAsync,
+						var x when x.Type == typeof(Memory<byte>) && x.IsNullable => DecodeMemoryOfCharNullableAsync,
+						var x when x.Type == typeof(ReadOnlySequence<byte>) && !x.IsNullable => DecodeReadOnlySequenceOfByteNonNullAsync,
+						var x when x.Type == typeof(ReadOnlySequence<byte>) && x.IsNullable => DecodeReadOnlySequenceOfByteNullableAsync,
+						var x when x.Type == typeof(ReadOnlySpan<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+						var x when x.Type == typeof(Span<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
+#warning TODO: PolymorphismSchema
+						_ =>
+							hasDeserializationConstructor ?
+								new AsyncDeserialization(context.GetSerializer(type, null).DeserializeObjectAsync) :
+								memberInfo switch
+								{
+									PropertyInfo p =>
+										p switch
+										{
+											var pi when pi.GetSetMethod(nonPublic: hasPriviledgedAccess) != null => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
+											_ => new AsyncDeserializingFill(context.GetSerializer(type, null).DeserializeObjectToAsync),
+										},
+									FieldInfo f =>
+										f switch
+										{
+											var fi when !fi.IsInitOnly => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
+											_ => new AsyncDeserializingFill(context.GetSerializer(type, null).DeserializeObjectToAsync),
+										},
+									_ => ReflectionSerializerThrow.UnexpectedMemberType(memberInfo)
+								}
+					};
+			}
+		}
+
+#endif // FEATURE_TAP
+
+		private static IEnumerable<bool> DetermineWhetherIndividualMembersAreCollection(IEnumerable<SerializingMember> members)
+		{
+			foreach (var member in members)
+			{
+				yield return member.Member?.GetMemberValueType()?.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+			}
+		}
+
+		private static IEnumerable<Func<object, object?>> CreateMemberValueGetters(IReadOnlyList<SerializingMember> members, IReadOnlyList<Type>? tupleTypes)
+		{
+			var nestAccessorList = new List<Func<object, object>>(tupleTypes?.Count ?? 0);
+			// immutable array for closure.
+			var nestAccessors = Array.Empty<Func<object, object>>();
+
+			for (var i = 0; i < members.Count; i++)
+			{
+				Func<object, object?>? itemAccessor = null;
+
+				if (tupleTypes != null)
+				{
+					var itemIndex = Math.DivRem(i, 7, out var depth) + 1;
+					if (itemIndex == 1 && depth > 0)
+					{
+						var restProperty = tupleTypes[depth - 1].GetProperty("Rest")!;
+						nestAccessorList.Add(t => restProperty.GetValue(t)!);
+						nestAccessors = nestAccessorList.ToArray();
+					}
+
+					var itemProperty = tupleTypes[depth].GetProperty($"Item{itemIndex}")!;
+					itemAccessor = t => itemProperty.GetValue(t)!;
+				}
+
+				var member = members[i];
+
+				if (tupleTypes != null)
+				{
+					Debug.Assert(itemAccessor != null);
+
+					yield return
+						t =>
+						{
+							foreach (var nestAccessor in nestAccessors)
+							{
+								t = nestAccessor(t);
+							}
+
+							return itemAccessor!(t);
+						};
+				}
+				else if (member.Member is PropertyInfo asProperty)
+				{
+					yield return o => asProperty.GetValue(o, BindingFlags.DoNotWrapExceptions, binder: null, index: null, culture: null);
+				}
+				else if (member.Member is FieldInfo asField)
+				{
+					yield return o => asField.GetValue(o);
+				}
+				else
+				{
+					ReflectionSerializerThrow.UnexpectedMemberType(member.Member);
+				}
+			}
+		}
+
+		private static IEnumerable<Action<object, object?>> CreateMemberValueSetters(IReadOnlyList<SerializingMember> members)
+		{
+			// Tuple is deserialized via constructor, so this method will not be called.
+
+			for (var i = 0; i < members.Count; i++)
+			{
+				var member = members[i];
+
+				if (member.Member is PropertyInfo asProperty)
+				{
+					yield return (o, v) => asProperty.SetValue(o, v, BindingFlags.DoNotWrapExceptions, binder: null, index: null, culture: null);
+				}
+				else if (member.Member is FieldInfo asField)
+				{
+					yield return (o, v) => asField.SetValue(o, v);
+				}
+				else
+				{
+					ReflectionSerializerThrow.UnexpectedMemberType(member.Member);
+				}
+			}
+		}
+
+		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
+		{
+			var encoder = context.Encoder;
+
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			if (context.SerializationMethod == SerializationMethod.Array)
+			{
+				encoder.EncodeArrayStart(this._memberValueEncoders.Count, sink, context.CollectionContext);
+
+				for (var i = 0; i < this._memberValueEncoders.Count; i++)
+				{
+					var value = this._memberValueGetters[i](obj);
+
+					encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
+					if (this._memberValueEncoders[i] is PrimitiveEncoder primitiveEncoder)
+					{
+						primitiveEncoder(encoder, value, sink);
+					}
+					else if (this._memberValueEncoders[i] is StringEncoder stringEncoder)
+					{
+						var encoding = this._target.Members[i].Member!.GetCustomAttribute<StringEncodingAttribute>()?.Encoding ?? context.StringEncoding;
+						stringEncoder(encoder, value, sink, encoding, context.CancellationToken);
+					}
+					else if (this._memberValueEncoders[i] is BinaryEncoder binaryEncoder)
+					{
+						binaryEncoder(encoder, value, sink, context.CancellationToken);
+					}
+					else if (this._memberValueEncoders[i] is Serialization serializer)
+					{
+						if (this._memberIsCollections[i])
+						{
+							context.IncrementDepth();
+						}
+
+						serializer(ref context, value, sink);
+
+						if (this._memberIsCollections[i])
+						{
+							context.DecrementDepth();
+						}
+					}
+					else
+					{
+						ReflectionSerializerThrow.UnexpectedEncoderDelegate(this._memberValueEncoders[i]);
+					}
+
+					encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
+				}
+
+				encoder.EncodeArrayEnd(this._memberValueEncoders.Count, sink, context.CollectionContext);
+			}
+			else
+			{
+				encoder.EncodeMapStart(this._memberValueEncoders.Count, sink, context.CollectionContext);
+
+				for (var i = 0; i < this._memberValueEncoders.Count; i++)
+				{
+					var value = this._memberValueGetters[i](obj);
+
+					encoder.EncodeMapKeyStart(i, sink, context.CollectionContext);
+					encoder.EncodeRawString(this._target.Members[i].Utf8MemberName!.AsSpan().Bytes, this._target.Members[i].MemberName!.Length, sink, context.CancellationToken);
+					encoder.EncodeMapKeyStart(i, sink, context.CollectionContext);
+
+					encoder.EncodeMapValueStart(i, sink, context.CollectionContext);
+					if (this._memberValueEncoders[i] is PrimitiveEncoder primitiveEncoder)
+					{
+						primitiveEncoder(encoder, value, sink);
+					}
+					else if (this._memberValueEncoders[i] is StringEncoder stringEncoder)
+					{
+						var encoding = this._target.Members[i].Member!.GetCustomAttribute<StringEncodingAttribute>()?.Encoding ?? context.StringEncoding;
+						stringEncoder(encoder, value, sink, encoding, context.CancellationToken);
+					}
+					else if (this._memberValueEncoders[i] is BinaryEncoder binaryEncoder)
+					{
+						binaryEncoder(encoder, value, sink, context.CancellationToken);
+					}
+					else if (this._memberValueEncoders[i] is Serialization serializer)
+					{
+						serializer(ref context, value, sink);
+					}
+					else
+					{
+						ReflectionSerializerThrow.UnexpectedEncoderDelegate(this._memberValueEncoders[i]);
+					}
+
+					encoder.EncodeMapValueEnd(i, sink, context.CollectionContext);
+				}
+
+				encoder.EncodeMapEnd(this._memberValueEncoders.Count, sink, context.CollectionContext);
+			}
+		}
+
+		public object? Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			if (context.Decoder.TryDecodeNull(ref source))
+			{
+				return null;
+			}
+
+			object? result = null;
+			var constructorParameters = this._target.DeserializationConstructor?.GetParameters() ?? Array.Empty<ParameterInfo>();
+			Dictionary<string, object?>? deserializedMembers = null;
+
+			if (this._target.DeserializationConstructor == null)
+			{
+				result = Activator.CreateInstance(this._target.Type);
+			}
+			else
+			{
+				deserializedMembers = new Dictionary<string, object?>(constructorParameters.Length);
+			}
+
+			var decoder = context.Decoder;
+
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				var collectionType = decoder.DecodeArrayOrMapHeader(ref source, out var itemsCount);
+				for (var i = 0; i < itemsCount; i++)
+				{
+					this.DeserializeMember(ref context, ref source, result, deserializedMembers, i, collectionType);
+				}
+			}
+			else
+			{
+				var collectionType = decoder.DecodeArrayOrMap(ref source, out var iterator);
+				for (var i = 0; !iterator.CollectionEnds(ref source); i++)
+				{
+					this.DeserializeMember(ref context, ref source, result, deserializedMembers, i, collectionType);
+					i++;
+				}
+			}
+
+			if (result == null)
+			{
+				Debug.Assert(deserializedMembers != null);
+				return this.CreateInstanceFromDeserializedMembers(constructorParameters, deserializedMembers);
+			}
+			else
+			{
+				return result;
+			}
+		}
+
+		public async ValueTask<object?> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			await source.FetchAsync(context.CancellationToken).ConfigureAwait(false);
+			
+			if (await context.Decoder.TryDecodeNullAsync(source, context.CancellationToken).ConfigureAwait(false))
+			{
+				return null;
+			}
+
+			object? result = null;
+			var constructorParameters = this._target.DeserializationConstructor?.GetParameters() ?? Array.Empty<ParameterInfo>();
+			Dictionary<string, object?>? deserializedMembers = null;
+
+			if (this._target.DeserializationConstructor == null)
+			{
+				result = Activator.CreateInstance(this._target.Type);
+			}
+			else
+			{
+				deserializedMembers = new Dictionary<string, object?>(constructorParameters.Length);
+			}
+
+			var decoder = context.Decoder;
+
+			if (decoder.Options.Features.CanCountCollectionItems)
+			{
+				var collectionTypeAndCount = await decoder.DecodeArrayOrMapHeaderAsync(source, context.CancellationToken).ConfigureAwait(false);
+				var collectionType = collectionTypeAndCount.CollectionType;
+				var itemsCount = collectionTypeAndCount.ItemsCount;
+				for (var i = 0; i < itemsCount; i++)
+				{
+					await this.DeserializeMemberAsync(context, source, result, deserializedMembers, i, collectionType).ConfigureAwait(false);
+				}
+			}
+			else
+			{
+				var collectionTypeAndIterator = await decoder.DecodeArrayOrMapAsync(source, context.CancellationToken).ConfigureAwait(false);
+				var collectionType = collectionTypeAndIterator.CollectionType;
+				var iterator = collectionTypeAndIterator.Iterator;
+				for (var i = 0; !(await iterator.CollectionEndsAsync(source, context.CancellationToken).ConfigureAwait(false)); i++)
+				{
+					await this.DeserializeMemberAsync(context, source, result, deserializedMembers, i, collectionType).ConfigureAwait(false);
+					i++;
+				}
+			}
+
+			if (result == null)
+			{
+				Debug.Assert(deserializedMembers != null);
+				return this.CreateInstanceFromDeserializedMembers(constructorParameters, deserializedMembers);
+			}
+			else
+			{
+				return result;
+			}
+		}
+
+		private void DeserializeMember(
+			ref DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			object? result,
+			Dictionary<string, object?>? deserializedMembers,
+			int i,
+			CollectionType collectionType
+		)
+		{
+			var decoder = context.Decoder;
+			string property;
+			int index;
+			if (collectionType.IsMap)
+			{
+				property = decoder.DecodeString(ref source, encoding: null, context.CancellationToken);
+				if (!this._memberIndexes.TryGetValue(property, out index))
+				{
+					// skip value of unknown member.
+					decoder.Skip(ref source, context.CollectionContext, context.CancellationToken);
+					return;
+				}
+			}
+			else
+			{
+				if (i > this._target.Members.Count)
+				{
+					// skip extra member.
+					decoder.Skip(ref source, context.CollectionContext, context.CancellationToken);
+					return;
+				}
+
+				index = i;
+				property = this._target.Members[i].MemberName ?? $"Item{i}";
+			}
+
+			object? value;
+			if (this._memberValueDecoders[index] is PrimitiveDecoder primitiveDecoder)
+			{
+				value = primitiveDecoder(decoder, ref source);
+			}
+			else if (this._memberValueDecoders[index] is StringDecoder stringDecoder)
+			{
+				value = stringDecoder(decoder, ref source, context.StringEncoding, context.CancellationToken);
+			}
+			else if (this._memberValueDecoders[index] is BinaryDecoder binaryDecoder)
+			{
+				value = binaryDecoder(decoder, ref source, context.CancellationToken);
+			}
+			else if (this._memberValueDecoders[index] is Deserialization deserializer)
+			{
+				if (this._memberIsCollections[index])
+				{
+					context.IncrementDepth();
+				}
+
+				value = deserializer(ref context, ref source);
+
+				if (this._memberIsCollections[index])
+				{
+					context.DecrementDepth();
+				}
+			}
+			else if (this._memberValueDecoders[index] is DeserializingFill filler)
+			{
+				Debug.Assert(result != null);
+
+				if (this._memberIsCollections[index])
+				{
+					context.IncrementDepth();
+				}
+
+				value = this._memberValueGetters[index](result);
+				if (value == null)
+				{
+					Throw.UnsettableCollectionMemberMustNotBeNull(this._target.Members[i].Member);
+				}
+
+				filler(ref context, ref source, value!);
+
+
+				if (this._memberIsCollections[index])
+				{
+					context.DecrementDepth();
+				}
+
+				// Assign is not required.
+				return;
+			}
+			else
+			{
+				ReflectionSerializerThrow.UnexpectedDecoderDelegate(this._memberValueDecoders[i]);
+				value = null;
+			}
+
+			if (result != null)
+			{
+				Debug.Assert(this._memberValueSetters != null);
+				this._memberValueSetters[index](result, value);
+			}
+			else
+			{
+				Debug.Assert(deserializedMembers != null);
+				deserializedMembers.Add(property, value);
+			}
+		}
+
+
+		private async ValueTask DeserializeMemberAsync(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			object? result,
+			Dictionary<string, object?>? deserializedMembers,
+			int i,
+			CollectionType collectionType
+		)
+		{
+			var decoder = context.Decoder;
+			string property;
+			int index;
+			if (collectionType.IsMap)
+			{
+				property = await decoder.DecodeStringAsync(source, context.CancellationToken).ConfigureAwait(false);
+				if (!this._memberIndexes.TryGetValue(property, out index))
+				{
+					// skip value of unknown member.
+					await decoder.SkipAsync(source, context.CollectionContext, context.CancellationToken).ConfigureAwait(false);
+					return;
+				}
+			}
+			else
+			{
+				if (i > this._target.Members.Count)
+				{
+					// skip extra member.
+					await decoder.SkipAsync(source, context.CollectionContext, context.CancellationToken).ConfigureAwait(false);
+					return;
+				}
+
+				index = i;
+				property = this._target.Members[i].MemberName ?? $"Item{i}";
+			}
+
+			object? value;
+			if (this._asyncMemberValueDecoders[index] is AsyncPrimitiveDecoder asyncPrimitiveDecoder)
+			{
+				value = await asyncPrimitiveDecoder(decoder, source, context.CancellationToken).ConfigureAwait(false);
+			}
+			else if (this._asyncMemberValueDecoders[index] is AsyncStringDecoder asyncStringDecoder)
+			{
+				value = await asyncStringDecoder(decoder, source, context.StringEncoding, context.CancellationToken).ConfigureAwait(false);
+			}
+			else if (this._asyncMemberValueDecoders[index] is AsyncBinaryDecoder asyncBinaryDecoder)
+			{
+				value = await asyncBinaryDecoder(decoder, source, context.CancellationToken).ConfigureAwait(false);
+			}
+			else if (this._asyncMemberValueDecoders[index] is AsyncDeserialization asyncDeserializer)
+			{
+				if (this._memberIsCollections[index])
+				{
+					context.IncrementDepth();
+				}
+
+				value = await asyncDeserializer(context, source).ConfigureAwait(false);
+
+				if (this._memberIsCollections[index])
+				{
+					context.DecrementDepth();
+				}
+			}
+			else if (this._asyncMemberValueDecoders[index] is AsyncDeserializingFill asyncFiller)
+			{
+				Debug.Assert(result != null);
+
+				if (this._memberIsCollections[index])
+				{
+					context.IncrementDepth();
+				}
+
+				value = this._memberValueGetters[index](result);
+				if (value == null)
+				{
+					Throw.UnsettableCollectionMemberMustNotBeNull(this._target.Members[i].Member);
+				}
+
+				await asyncFiller(context, source, value!).ConfigureAwait(false);
+
+
+				if (this._memberIsCollections[index])
+				{
+					context.DecrementDepth();
+				}
+
+				// Assign is not required.
+				return;
+			}
+			else
+			{
+				ReflectionSerializerThrow.UnexpectedDecoderDelegate(this._memberValueDecoders[i]);
+				value = null;
+			}
+
+			if (result != null)
+			{
+				Debug.Assert(this._memberValueSetters != null);
+				this._memberValueSetters[index](result, value);
+			}
+			else
+			{
+				Debug.Assert(deserializedMembers != null);
+				deserializedMembers.Add(property, value);
+			}
+		}
+
+		private object? CreateInstanceFromDeserializedMembers(ParameterInfo[] constructorParameters, Dictionary<string, object?> deserializedMembers)
+		{
+			var constructorArguments =
+				constructorParameters
+				.Select((p, i) => (Type: p.ParameterType, CorrespondentMemberName: this._target.GetCorrespondentMemberName(i)))
+				.Select(x => deserializedMembers.TryGetValue(x.CorrespondentMemberName ?? String.Empty, out var value) ? value : Activator.CreateInstance(x.Type))
+				.ToList();
+
+			if (this._tupleTypes != null)
+			{
+				object? rest = null;
+				var tupleTypeStack = new Stack<Type>(this._tupleTypes);
+				while (tupleTypeStack.Any())
+				{
+					var currentType = tupleTypeStack.Pop();
+					var currentParameters = currentType.GetConstructors().Where(x => x.IsPublic && !x.IsStatic).Select(x => x.GetParameters()).SingleOrDefault(x => x.Length > 0);
+					var fillingArgumentsCount = currentParameters.Length == 8 ? 7 : currentParameters.Length;
+					var currentArguments = new object?[currentParameters.Length];
+					var offset = constructorArguments.Count - fillingArgumentsCount;
+					for (var i = 0; i < fillingArgumentsCount; i++)
+					{
+						currentArguments[i] = constructorArguments[offset + i];
+					}
+					constructorArguments.RemoveRange(offset, fillingArgumentsCount);
+
+					if (currentArguments.Length == 8)
+					{
+						currentArguments[7] = rest;
+					}
+
+					rest = Activator.CreateInstance(currentType, currentArguments);
+				}
+
+				return rest;
+			}
+			else
+			{
+				return Activator.CreateInstance(this._target.Type, constructorArguments)!;
+			}
+		}
+
+		public bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, object obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(this._target.Type);
+			// never
+			return default;
+		}
+
+		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, object obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(this._target.Type);
+			// never
+			return default;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs
new file mode 100644
index 000000000..ef9c744f5
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs
@@ -0,0 +1,12 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal sealed class ReflectionSerializerBuilder : SerializerBuilder
+	{
+		public sealed override ObjectSerializer<T> Build<T>(ObjectSerializationContext context, SerializationTarget target)
+			=> new ReflectionSerializer<T>(context, target);
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerThrow.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerThrow.cs
new file mode 100644
index 000000000..efc46a790
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerThrow.cs
@@ -0,0 +1,25 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Reflection;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	internal static class ReflectionSerializerThrow
+	{
+		public static Delegate UnexpectedMemberType(MemberInfo member)
+			=> throw new Exception($"Assertion failure: unexpected MemberInfo type '{member}'({member.GetType()})");
+
+		public static void UnexpectedEncoderDelegate(Delegate @delegate)
+			=> throw new Exception($"Assertion failure: unexpected encoder delegate '{@delegate}'.");
+
+		public static void UnexpectedDecoderDelegate(Delegate @delegate)
+			=> throw new Exception($"Assertion failure: unexpected encoder delegate '{@delegate}'.");
+
+		public static Delegate ByRefLikeIsNotSupported(MemberInfo member)
+			// This should be able to be handled in future runtime...
+			=> throw new PlatformNotSupportedException($"Cannot deserialize {member} because its type ({member.GetMemberValueType()}) is \"by-ref\" type. Reflection based serializer cannot handle it in current runtime.");
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs
new file mode 100644
index 000000000..7f3e8bff2
--- /dev/null
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs
@@ -0,0 +1,113 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.ReflectionSerializers
+{
+	/// <summary>
+	///		 Implements non optimized, reflection based serializer.
+	/// </summary>
+	/// <typeparam name="T">Type of serialization target.</typeparam>
+	internal sealed partial class ReflectionSerializer<T> : ObjectSerializer<T>
+	{
+		// T is PrimitiveEncoder | Stringncoder | BinaryEncoder | ExtensionEncoder | ArrayEncoderToken | DictionaryEncoderToken
+		private readonly Serialization _serialize;
+		private readonly Deserialization _deserialize;
+		private readonly DeserializingFill _deserializeTo;
+#if FEATURE_TAP
+		private readonly AsyncDeserialization _deserializeAsync;
+		private readonly AsyncDeserializingFill _deserializeToAsync;
+#endif // FEATURE_TAP
+
+		public ReflectionSerializer(ObjectSerializationContext ownerContext, SerializationTarget target)
+			: base(ownerContext, target.GetCapabilities())
+		{
+#warning TODO: PolymorphismSchema
+
+			IReflectionObjectSerializer serializer;
+			if (!target.IsCollection)
+			{
+				serializer = new ObjectDelegateSerializer(ownerContext, target);
+			}
+			else if (target.CollectionTraits.CollectionType == CollectionKind.Array)
+			{
+#warning TODO: PolymorphismSchema
+				var itemSerializer = ownerContext.GetSerializer(target.CollectionTraits.ElementType!, null);
+				serializer =
+					target.CollectionTraits.DetailedCollectionType switch
+					{
+						CollectionDetailedKind.Array
+							=> new ArrayDelegateSerializer(
+								itemSerializer.SerializeObject,
+								itemSerializer.DeserializeObject,
+#if FEATURE_TAP
+								itemSerializer.DeserializeObjectAsync,
+#endif // FEATURE_TAP
+								target.Type,
+								target.CollectionTraits
+							),
+						_ => new CollectionDelegateSerializer(
+							itemSerializer.SerializeObject,
+							itemSerializer.DeserializeObject,
+#if FEATURE_TAP
+							itemSerializer.DeserializeObjectAsync,
+#endif // FEATURE_TAP
+							target.Type,
+							target.CollectionTraits
+						)
+					};
+			}
+			else
+			{
+				// Map
+				var (keyType, valueType) = target.CollectionTraits.GetKeyValueType();
+#warning TODO: PolymorphismSchema
+				var keySerializer = ownerContext.GetSerializer(keyType!, null);
+#warning TODO: PolymorphismSchema
+				var valueSerializer = ownerContext.GetSerializer(valueType!, null);
+				serializer =
+					new DictionaryDelegateSerializer(
+						keySerializer.SerializeObject,
+						valueSerializer.SerializeObject,
+						keySerializer.DeserializeObject,
+						valueSerializer.DeserializeObject,
+#if FEATURE_TAP
+						keySerializer.DeserializeObjectAsync,
+						valueSerializer.DeserializeObjectAsync,
+#endif // FEATURE_TAP
+						target.Type,
+						target.CollectionTraits
+					);
+			}
+
+			this._serialize = serializer.Serialize;
+			this._deserialize = serializer.Deserialize;
+			this._deserializeTo = serializer.DeserializeTo;
+#if FEATURE_TAP
+			this._deserializeAsync = serializer.DeserializeAsync;
+			this._deserializeToAsync = serializer.DeserializeToAsync;
+#endif // FEATURE_TAP
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink)
+			=> this._serialize(ref context, obj, sink);
+
+		[return: MaybeNull]
+		public sealed override T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> (T)this._deserialize(ref context, ref source);
+
+		public sealed override async ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+			=> (T)(await this._deserializeAsync(context, source).ConfigureAwait(false))!;
+
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj)
+			=> this._deserializeTo(ref context, ref source, Ensure.NotNull(obj));
+
+		public sealed override async ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj)
+			=> await this._deserializeToAsync(context, source, Ensure.NotNull(obj)).ConfigureAwait(false);
+	}
+}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs
deleted file mode 100644
index aded3dd65..000000000
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`2.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using MsgPack.Internal;
-using MsgPack.Serialization;
-using MsgPack.Serialization.Internal;
-
-namespace Msgpack.Serialization.ReflectionSerializers
-{
-	internal abstract class SerializerBuilder
-	{
-		public abstract IObjectSerializer<T, TExtensionType> Build<T, TExtensionType>(SerializationTarget target);
-	}
-
-	internal sealed class ReflectionSerializerBuilder : SerializerBuilder
-	{
-		public sealed override IObjectSerializer<T, TExtensionType> Build<T, TExtensionType>(SerializationTarget target, SerializerGenerationOptions options)
-			=> new ReflectionSerializer<T, TExtensionType>(target, options);
-	}
-
-	/// <summary>
-	///		 Implements non optimized, reflection based serializer.
-	/// </summary>
-	/// <typeparam name="T">Type of serialization target.</typeparam>
-	/// <typeparam name="TExtensionType">Type of extention type specific to codec.</typeparam>
-	internal sealed class ReflectionSerializer<T, TExtensionType> : IObjectSerializer<T, TExtensionType>
-	{
-		private readonly SerializerGenerationOptions _options;
-#warning TODO: Use _options
-		private bool UsesArray => true;
-		// T is PrimitiveEncoder | Stringncoder | BinaryEncoder | ExtensionEncoder | ArrayEncoderToken | DictionaryEncoderToken
-		private readonly IReadOnlyList<object> _memberValueEncoders;
-		private readonly IReadOnlyList<byte[]> _memberUtf8Names;
-		private readonly IReadOnlyList<object> _memberValueDecoders;
-
-		private delegate void PrimitiveEncoder(Encoder<TExtensionType> encoder, object value, IBufferWriter<byte> writer);
-		private delegate void Stringncoder(Encoder<TExtensionType> encoder, object value, IBufferWriter<byte> writer, Encoding? encoding, CancellationToken cancellationToken);
-		private delegate void BinaryEncoder(Encoder<TExtensionType> encoder, object ovaluebj, IBufferWriter<byte> writer, CancellationToken cancellationToken);
-		private delegate void ExtensionEncoder(Encoder<TExtensionType> encoder, TExtensionType extensionType, in ReadOnlySequence<byte> body, IBufferWriter<byte> writer, CancellationToken cancellationToken);
-
-		public void Serialize(ref SerializationOperationContext<TExtensionType> context, [AllowNull] T obj, IBufferWriter<byte> sink)
-		{
-			var encoder = context.Encoder;
-			if (obj is null)
-			{
-				encoder.EncodeNull(sink);
-				return;
-			}
-
-			if (this.UsesArray)
-			{
-				encoder.EncodeArrayStart(this._memberValueEncoders.Count, sink, context.CollectionContext);
-
-				for(var i = 0; i < this._memberValueEncoders.Count;i++)
-				{
-					encoder.EncodeArrayItemStart(i, sink, context.CollectionContext);
-					if (this._memberValueEncoders[i] is Action<object, IBufferWriter<byte>> primitiveEncoder)
-					{
-						encoder.EncodeBinary()
-					}
-					else if (this._memberValueEncoders[i] is Action<object, IBufferWriter<byte>, Encoding?, CancellationToken> stringEncoder)
-					{
-
-					}
-					else if (this._memberValueEncoders[i] is Action<object, IBufferWriter<byte>, CancellationToken> binaryEncoder)
-					{
-
-					}
-					else if (this._memberValueEncoders[i] is Action<object, ReadOnlySequence<byte>, IBufferWriter<byte>> extensionEncoder)
-					{
-						encoder.EncodeExtension()
-					}
-					else
-					{
-						Debug.Fail();
-					}
-					encoder.EncodeArrayItemEnd(i, sink, context.CollectionContext);
-				}
-
-				encoder.EncodeArrayEnd(this._memberValueEncoders.Count, sink, context.CollectionContext);
-
-			}
-			
-
-
-			throw new NotImplementedException();
-		}
-
-		public async ValueTask SerializeAsync(AsyncSerializationOperationContext<TExtensionType> context, [AllowNull] T obj, Stream streamSink)
-		{
-			await using (var writer = new StreamBufferWriter(streamSink, ownsStream: false, ArrayPool<byte>.Shared, cleansBuffer: true))
-			{
-				var serializationOperationContext = context.AsSerializationOperationContext();
-				this.Serialize(ref serializationOperationContext, obj, writer);
-			}
-		}
-
-		[return: MaybeNull]
-		public T Deserialize(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource)
-		{
-			throw new NotImplementedException();
-		}
-
-		public bool DeserializeTo(ref DeserializationOperationContext<TExtensionType> context, ref SequenceReader<byte> source, in T obj)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext<TExtensionType> context, Stream streamSource, T obj)
-		{
-			throw new NotImplementedException();
-		}
-	}
-}

From dcc171a6b26b5a27cc250fbb653d738561f179fc Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Fri, 26 Jun 2020 20:18:20 +0900
Subject: [PATCH 39/82] Add ILTranspiler

---
 .../MsgPack.Serialization.ILGeneration.csproj |  26 +-
 .../Reflection/ILGenerationContext.cs         | 434 +++++++++
 .../Reflection/ILTranslator.Parse.cs          | 907 ++++++++++++++++++
 .../Reflection/ILTranslator.Parse.tt          |  82 ++
 .../Serialization/Reflection/ILTranspiler.cs  | 308 ++++++
 .../Reflection/MethodSignature.cs             |  43 +
 6 files changed, 1799 insertions(+), 1 deletion(-)
 create mode 100644 src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILGenerationContext.cs
 create mode 100644 src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.cs
 create mode 100644 src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.tt
 create mode 100644 src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranspiler.cs
 create mode 100644 src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/MethodSignature.cs

diff --git a/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj b/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj
index a20cb1dcc..336aa7704 100644
--- a/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj
+++ b/src/MsgPack.Serialization.ILGeneration/MsgPack.Serialization.ILGeneration.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
@@ -12,7 +13,30 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="Serialization\Reflection\" />
+    <None Include="Serialization\Reflection\ILTranslator.Parse.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>ILTranslator.Parse.tt</DependentUpon>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="Serialization\Reflection\ILTranslator.Parse.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>ILTranslator.Parse.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Serialization\Reflection\ILTranslator.Parse.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>ILTranslator.Parse.tt</DependentUpon>
+    </Compile>
   </ItemGroup>
 
 </Project>
diff --git a/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILGenerationContext.cs b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILGenerationContext.cs
new file mode 100644
index 000000000..15d6eaf6e
--- /dev/null
+++ b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILGenerationContext.cs
@@ -0,0 +1,434 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace MsgPack.Serialization.Reflection
+{
+	internal sealed class ILGenerationContext
+	{
+		private struct TypeEntry
+		{
+			public TypeBuilder TypeBuilder { get; }
+			public IReadOnlyDictionary<string, FieldBuilder> Fields { get; }
+			public IReadOnlyDictionary<MethodSignature, (ConstructorInfo Original, ConstructorBuilder Builder)> Constructors { get; }
+			public IReadOnlyDictionary<MethodSignature, (MethodInfo Original, MethodBuilder Builder)> Methods { get; }
+
+			public TypeEntry(
+				TypeBuilder typeBuilder,
+				Dictionary<string, FieldBuilder> fields,
+				Dictionary<MethodSignature, (ConstructorInfo Original, ConstructorBuilder Builder)> constructors,
+				Dictionary<MethodSignature, (MethodInfo Original, MethodBuilder Builder)> methods
+			)
+			{
+				this.TypeBuilder = typeBuilder;
+				this.Fields = fields;
+				this.Constructors = constructors;
+				this.Methods = methods;
+			}
+		}
+
+		private readonly AssemblyBuilder _assemblyBuilder;
+		private readonly ModuleBuilder _moduleBuilder;
+		private readonly Dictionary<string, TypeEntry> _typeBuilders = new Dictionary<string, TypeEntry>();
+		private readonly Dictionary<MethodSignature, (MethodInfo Original, MethodBuilder Builder)> _globalMethods = new Dictionary<MethodSignature, (MethodInfo Original, MethodBuilder Builder)>();
+		private readonly Dictionary<string, FieldBuilder> _globalFields = new Dictionary<string, FieldBuilder>();
+
+		public ILGenerationContext(string assemblyName, AssemblyBuilderAccess access)
+		{
+			this._assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(assemblyName), access);
+			this._moduleBuilder = this._assemblyBuilder.DefineDynamicModule($"{assemblyName}.dll");
+		}
+
+#warning TODO: ILGeneration
+
+		public IEnumerable<Type> MakeTypes()
+		{
+			foreach (var typeBuilder in this._typeBuilders)
+			{
+				if (typeBuilder.Value.TypeBuilder.IsCreated())
+				{
+					continue;
+				}
+
+				var type = typeBuilder.Value.TypeBuilder.CreateType();
+				// Type may be null if typeB
+				if (type != null)
+				{
+					yield return type;
+				}
+			}
+		}
+
+		private static CustomAttributeBuilder ToAttributeBuilder(CustomAttributeData attributeData)
+		{
+			if (attributeData.NamedArguments.Count == 0)
+			{
+				return new CustomAttributeBuilder(attributeData.Constructor, attributeData.ConstructorArguments.Select(a => a.Value).ToArray());
+			}
+			else
+			{
+				var fields = new List<FieldInfo>();
+				var fieldValues = new List<object>();
+				var properties = new List<PropertyInfo>();
+				var propertyValues = new List<object>();
+
+				foreach (var argument in attributeData.NamedArguments)
+				{
+					if (argument.TypedValue.Value is null)
+					{
+						continue;
+					}
+
+					if (argument.IsField)
+					{
+						fields.Add((argument.MemberInfo as FieldInfo)!);
+						fieldValues.Add(argument.TypedValue.Value);
+					}
+					else
+					{
+						properties.Add((argument.MemberInfo as PropertyInfo)!);
+						propertyValues.Add(argument.TypedValue.Value);
+					}
+				}
+
+				return
+					new CustomAttributeBuilder(
+						attributeData.Constructor,
+						attributeData.ConstructorArguments.Select(a => a.Value).ToArray(),
+						properties.ToArray(),
+						propertyValues.ToArray(),
+						fields.ToArray(),
+						fieldValues.ToArray()
+					);
+			}
+		}
+
+		private TypeEntry GetSharedType(Type type)
+		{
+			const BindingFlags AllFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+
+			if (this._typeBuilders.TryGetValue(type.FullName!, out var typeEntry))
+			{
+				return typeEntry;
+			}
+
+			var fields = new Dictionary<string, FieldBuilder>();
+			var constructors = new Dictionary<MethodSignature, (ConstructorInfo Original, ConstructorBuilder Builder)>();
+			var methods = new Dictionary<MethodSignature, (MethodInfo Original, MethodBuilder Builder)>();
+
+			var typeBuilder =
+				this._moduleBuilder.DefineType(
+					type.FullName!,
+					type.Attributes,
+					type.BaseType,
+					type.GetInterfaces()
+				);
+
+			foreach (var attribute in type.GetCustomAttributesData())
+			{
+				typeBuilder.SetCustomAttribute(ToAttributeBuilder(attribute));
+			}
+
+			foreach (var field in type.GetFields(AllFlags))
+			{
+				if ((field.Attributes & FieldAttributes.HasFieldRVA) == 0)
+				{
+					// normal field
+					var builder = typeBuilder.DefineField(field.Name, field.FieldType, field.GetRequiredCustomModifiers(), field.GetOptionalCustomModifiers(), field.Attributes);
+					var constant = field.GetRawConstantValue();
+					if (constant != null)
+					{
+						builder.SetConstant(constant);
+					}
+
+					foreach (var attribute in field.GetCustomAttributesData())
+					{
+						builder.SetCustomAttribute(ToAttributeBuilder(attribute));
+					}
+
+					fields[field.Name] = builder;
+				}
+				else
+				{
+					// RVA field -- for example, back-end of ReadOnlySpan<byte> S => new byte[] { 1, 2, 3 } to avoid newarr.
+					var value = field.GetValue(null);
+					if (value == null)
+					{
+						throw new NotSupportedException($"RVA field must have value type object.");
+					}
+
+					// Value is non public struct which has size that is equal to .sdata section bytes.
+					// So, reinterpret it as byte span and get data as byte array thorugh the span.
+
+					// First, pin boxed value object in GC heap.
+					var valueHandle = GCHandle.Alloc(value, GCHandleType.Pinned);
+					try
+					{
+						ReadOnlySpan<byte> data;
+						unsafe
+						{
+							// Reinterpret pinned object reference as pointer.
+							void* pValue = valueHandle.AddrOfPinnedObject().ToPointer();
+							// Reinterpret boxed object reference as byte span for unmanaged memory.
+							// Note that value type's size can be gotten from Marshal.SizeOf(object).
+							data = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AsRef<byte>(pValue), Marshal.SizeOf(value));
+						}
+
+						var builder = typeBuilder.DefineInitializedData(field.Name, data.ToArray(), field.Attributes);
+						foreach (var attribute in field.GetCustomAttributesData())
+						{
+							builder.SetCustomAttribute(ToAttributeBuilder(attribute));
+						}
+
+						fields[field.Name] = builder;
+					}
+					finally
+					{
+						valueHandle.Free();
+					}
+				}
+			}
+
+			foreach (var constructor in type.GetConstructors(AllFlags))
+			{
+				var builder =
+					typeBuilder.DefineConstructor(
+						constructor.Attributes,
+						constructor.CallingConvention,
+						constructor.GetParameters().Select(p => p.ParameterType).ToArray()
+					);
+				builder.SetImplementationFlags(builder.GetMethodImplementationFlags());
+
+				foreach (var attribute in builder.GetCustomAttributesData())
+				{
+					builder.SetCustomAttribute(ToAttributeBuilder(attribute));
+				}
+
+				constructors[new MethodSignature(constructor)] = (constructor, builder);
+			}
+
+			foreach (var method in type.GetMethods(AllFlags))
+			{
+				var parameters = method.GetParameters();
+				var builder =
+					typeBuilder.DefineMethod(
+						method.Name,
+						method.Attributes,
+						method.CallingConvention,
+						method.ReturnParameter.ParameterType,
+						method.ReturnParameter.GetRequiredCustomModifiers(),
+						method.ReturnParameter.GetOptionalCustomModifiers(),
+						parameters.Select(p => p.ParameterType).ToArray(),
+						parameters.Select(p => p.GetRequiredCustomModifiers()).ToArray(),
+						parameters.Select(p => p.GetOptionalCustomModifiers()).ToArray()
+					);
+				builder.SetImplementationFlags(builder.GetMethodImplementationFlags());
+
+				foreach (var attribute in builder.GetCustomAttributesData())
+				{
+					builder.SetCustomAttribute(ToAttributeBuilder(attribute));
+				}
+
+				methods[new MethodSignature(method)] = (method, builder);
+			}
+
+			foreach (var property in type.GetProperties(AllFlags))
+			{
+				var parameters = property.GetIndexParameters();
+				var builder =
+					typeBuilder.DefineProperty(
+						property.Name,
+						property.Attributes,
+						property.PropertyType,
+						property.GetRequiredCustomModifiers(),
+						property.GetOptionalCustomModifiers(),
+						parameters.Select(p => p.ParameterType).ToArray(),
+						parameters.Select(p => p.GetRequiredCustomModifiers()).ToArray(),
+						parameters.Select(p => p.GetOptionalCustomModifiers()).ToArray()
+					);
+
+				var constant = property.GetRawConstantValue();
+				if (constant != null)
+				{
+					builder.SetConstant(constant);
+				}
+
+				foreach (var attribute in property.GetCustomAttributesData())
+				{
+					builder.SetCustomAttribute(ToAttributeBuilder(attribute));
+				}
+
+				var getter = property.GetGetMethod(nonPublic: true);
+				if (getter != null)
+				{
+					builder.SetGetMethod(methods[new MethodSignature(getter)].Builder);
+				}
+
+				var setter = property.GetSetMethod(nonPublic: true);
+				if (setter != null)
+				{
+					builder.SetGetMethod(methods[new MethodSignature(setter)].Builder);
+				}
+			}
+
+
+			foreach (var @event in type.GetEvents(AllFlags))
+			{
+				var builder =
+					typeBuilder.DefineEvent(
+						@event.Name,
+						@event.Attributes,
+						@event.EventHandlerType!
+					);
+
+				foreach (var attribute in @event.GetCustomAttributesData())
+				{
+					builder.SetCustomAttribute(ToAttributeBuilder(attribute));
+				}
+
+				var getter = @event.GetAddMethod(nonPublic: true);
+				if (getter != null)
+				{
+					builder.SetAddOnMethod(methods[new MethodSignature(getter)].Builder);
+				}
+
+				var setter = @event.GetRemoveMethod(nonPublic: true);
+				if (setter != null)
+				{
+					builder.SetRemoveOnMethod(methods[new MethodSignature(setter)].Builder);
+				}
+
+				var raise = @event.GetRaiseMethod(nonPublic: true);
+				if (raise != null)
+				{
+					builder.SetRaiseMethod(methods[new MethodSignature(raise)].Builder);
+				}
+
+				foreach (var other in @event.GetOtherMethods(nonPublic: true))
+				{
+					builder.AddOtherMethod(methods[new MethodSignature(other)].Builder);
+				}
+			}
+
+			typeEntry = new TypeEntry(typeBuilder, fields, constructors, methods);
+			this._typeBuilders[type.FullName!] = typeEntry;
+
+			return typeEntry;
+		}
+
+		public MethodInfo ResolveMethod(MethodBase declaringMethod, int token)
+		{
+			var typeArguments = declaringMethod.DeclaringType?.GetGenericArguments();
+			var methodArguments = declaringMethod.GetGenericArguments();
+			var result = declaringMethod.Module.ResolveMethod(token, (typeArguments ?? Array.Empty<Type>()).Length == 0 ? null : typeArguments, methodArguments.Length == 0 ? null : methodArguments);
+			if (result == null)
+			{
+				// result may be null when the token indicates unresolvable DynamicMethod
+				throw new NotSupportedException($"Cannot resolve dynamic method token 0x{token:X8} in module '{declaringMethod.Module}'.");
+			}
+
+			if (!result.IsPublic && !result.IsFamily)
+			{
+				throw new InvalidOperationException($"{result.DeclaringType}.{result} is not public.");
+			}
+
+			if (!(result is MethodInfo method))
+			{
+				throw new InvalidOperationException($"{result.DeclaringType}.{result} is not a method.");
+			}
+
+			var declaringType = result.DeclaringType;
+
+			if (declaringType == null)
+			{
+				throw new NotImplementedException("Global function is not implemented.");
+			}
+
+			if (declaringType.IsPublic)
+			{
+				return method;
+			}
+
+			return this.GetSharedType(declaringType).Methods[new MethodSignature(method)].Builder;
+		}
+
+		public ConstructorInfo ResolveConstructor(MethodBase declaringMethod, int token)
+		{
+			var typeArguments = declaringMethod.DeclaringType?.GetGenericArguments();
+			var methodArguments = declaringMethod.GetGenericArguments();
+			var result = declaringMethod.Module.ResolveMethod(token, (typeArguments ?? Array.Empty<Type>()).Length == 0 ? null : typeArguments, methodArguments.Length == 0 ? null : methodArguments);
+			if (!(result is ConstructorInfo constructor))
+			{
+				throw new InvalidOperationException($"Method token 0x{token:X8} in module '{declaringMethod.Module}' may be dynamic method, it is not a constructor.");
+			}
+
+			if (!result.IsPublic && !result.IsFamily)
+			{
+				throw new InvalidOperationException($"{result.DeclaringType}.{result} is not public.");
+			}
+
+			var declaringType = constructor.DeclaringType!;
+
+			if (declaringType.IsPublic)
+			{
+				return constructor;
+			}
+
+			return this.GetSharedType(declaringType).Constructors[new MethodSignature(constructor)].Builder;
+		}
+
+		public FieldInfo ResolveField(MethodBase declaringMethod, int token)
+		{
+			var typeArguments = declaringMethod.DeclaringType?.GetGenericArguments();
+			var methodArguments = declaringMethod.GetGenericArguments();
+			var result = declaringMethod.Module.ResolveField(token, (typeArguments ?? Array.Empty<Type>()).Length == 0 ? null : typeArguments, methodArguments.Length == 0 ? null : methodArguments);
+
+			// FieldInfo should not be null here.
+			if (!result!.IsPublic && !result.IsFamily)
+			{
+				throw new InvalidOperationException($"{result.DeclaringType}.{result} is not public.");
+			}
+
+			var declaringType = result.DeclaringType;
+
+			if (declaringType == null)
+			{
+				throw new NotImplementedException("Global field is not implemented.");
+			}
+
+			if (declaringType.IsPublic)
+			{
+				return result;
+			}
+
+			return this.GetSharedType(declaringType).Fields[result.Name];
+		}
+
+		public Type ResolveType(MethodBase declaringMethod, int token)
+		{
+			var typeArguments = declaringMethod.DeclaringType?.GetGenericArguments();
+			var methodArguments = declaringMethod.GetGenericArguments();
+			var result = declaringMethod.Module.ResolveType(token, (typeArguments ?? Array.Empty<Type>()).Length == 0 ? null : typeArguments, methodArguments.Length == 0 ? null : methodArguments);
+
+			if (result.IsNested)
+			{
+				throw new NotImplementedException("Not implemented yet.");
+			}
+
+			if (result.IsPublic)
+			{
+				return result;
+			}
+
+			return this.GetSharedType(result).TypeBuilder;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.cs b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.cs
new file mode 100644
index 000000000..5ce88fa2f
--- /dev/null
+++ b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.cs
@@ -0,0 +1,907 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers.Binary;
+using System.Reflection.Emit;
+
+namespace MsgPack.Serialization.Reflection
+{
+	partial class ILTranspiler
+	{
+		private static OpCode Parse(Span<byte> il)
+		{
+			switch(il[0])
+			{
+				case 0x00:
+				{
+					return OpCodes.Nop; // nop InlineNone
+				}
+				case 0x01:
+				{
+					return OpCodes.Break; // break InlineNone
+				}
+				case 0x02:
+				{
+					return OpCodes.Ldarg_0; // ldarg.0 InlineNone
+				}
+				case 0x03:
+				{
+					return OpCodes.Ldarg_1; // ldarg.1 InlineNone
+				}
+				case 0x04:
+				{
+					return OpCodes.Ldarg_2; // ldarg.2 InlineNone
+				}
+				case 0x05:
+				{
+					return OpCodes.Ldarg_3; // ldarg.3 InlineNone
+				}
+				case 0x06:
+				{
+					return OpCodes.Ldloc_0; // ldloc.0 InlineNone
+				}
+				case 0x07:
+				{
+					return OpCodes.Ldloc_1; // ldloc.1 InlineNone
+				}
+				case 0x08:
+				{
+					return OpCodes.Ldloc_2; // ldloc.2 InlineNone
+				}
+				case 0x09:
+				{
+					return OpCodes.Ldloc_3; // ldloc.3 InlineNone
+				}
+				case 0x0A:
+				{
+					return OpCodes.Stloc_0; // stloc.0 InlineNone
+				}
+				case 0x0B:
+				{
+					return OpCodes.Stloc_1; // stloc.1 InlineNone
+				}
+				case 0x0C:
+				{
+					return OpCodes.Stloc_2; // stloc.2 InlineNone
+				}
+				case 0x0D:
+				{
+					return OpCodes.Stloc_3; // stloc.3 InlineNone
+				}
+				case 0x0E:
+				{
+					return OpCodes.Ldarg_S; // ldarg.s ShortInlineVar
+				}
+				case 0x0F:
+				{
+					return OpCodes.Ldarga_S; // ldarga.s ShortInlineVar
+				}
+				case 0x10:
+				{
+					return OpCodes.Starg_S; // starg.s ShortInlineVar
+				}
+				case 0x11:
+				{
+					return OpCodes.Ldloc_S; // ldloc.s ShortInlineVar
+				}
+				case 0x12:
+				{
+					return OpCodes.Ldloca_S; // ldloca.s ShortInlineVar
+				}
+				case 0x13:
+				{
+					return OpCodes.Stloc_S; // stloc.s ShortInlineVar
+				}
+				case 0x14:
+				{
+					return OpCodes.Ldnull; // ldnull InlineNone
+				}
+				case 0x15:
+				{
+					return OpCodes.Ldc_I4_M1; // ldc.i4.m1 InlineNone
+				}
+				case 0x16:
+				{
+					return OpCodes.Ldc_I4_0; // ldc.i4.0 InlineNone
+				}
+				case 0x17:
+				{
+					return OpCodes.Ldc_I4_1; // ldc.i4.1 InlineNone
+				}
+				case 0x18:
+				{
+					return OpCodes.Ldc_I4_2; // ldc.i4.2 InlineNone
+				}
+				case 0x19:
+				{
+					return OpCodes.Ldc_I4_3; // ldc.i4.3 InlineNone
+				}
+				case 0x1A:
+				{
+					return OpCodes.Ldc_I4_4; // ldc.i4.4 InlineNone
+				}
+				case 0x1B:
+				{
+					return OpCodes.Ldc_I4_5; // ldc.i4.5 InlineNone
+				}
+				case 0x1C:
+				{
+					return OpCodes.Ldc_I4_6; // ldc.i4.6 InlineNone
+				}
+				case 0x1D:
+				{
+					return OpCodes.Ldc_I4_7; // ldc.i4.7 InlineNone
+				}
+				case 0x1E:
+				{
+					return OpCodes.Ldc_I4_8; // ldc.i4.8 InlineNone
+				}
+				case 0x1F:
+				{
+					return OpCodes.Ldc_I4_S; // ldc.i4.s ShortInlineI
+				}
+				case 0x20:
+				{
+					return OpCodes.Ldc_I4; // ldc.i4 InlineI
+				}
+				case 0x21:
+				{
+					return OpCodes.Ldc_I8; // ldc.i8 InlineI8
+				}
+				case 0x22:
+				{
+					return OpCodes.Ldc_R4; // ldc.r4 ShortInlineR
+				}
+				case 0x23:
+				{
+					return OpCodes.Ldc_R8; // ldc.r8 InlineR
+				}
+				case 0x25:
+				{
+					return OpCodes.Dup; // dup InlineNone
+				}
+				case 0x26:
+				{
+					return OpCodes.Pop; // pop InlineNone
+				}
+				case 0x27:
+				{
+					return OpCodes.Jmp; // jmp InlineMethod
+				}
+				case 0x28:
+				{
+					return OpCodes.Call; // call InlineMethod
+				}
+				case 0x29:
+				{
+					return OpCodes.Calli; // calli InlineSig
+				}
+				case 0x2A:
+				{
+					return OpCodes.Ret; // ret InlineNone
+				}
+				case 0x2B:
+				{
+					return OpCodes.Br_S; // br.s ShortInlineBrTarget
+				}
+				case 0x2C:
+				{
+					return OpCodes.Brfalse_S; // brfalse.s ShortInlineBrTarget
+				}
+				case 0x2D:
+				{
+					return OpCodes.Brtrue_S; // brtrue.s ShortInlineBrTarget
+				}
+				case 0x2E:
+				{
+					return OpCodes.Beq_S; // beq.s ShortInlineBrTarget
+				}
+				case 0x2F:
+				{
+					return OpCodes.Bge_S; // bge.s ShortInlineBrTarget
+				}
+				case 0x30:
+				{
+					return OpCodes.Bgt_S; // bgt.s ShortInlineBrTarget
+				}
+				case 0x31:
+				{
+					return OpCodes.Ble_S; // ble.s ShortInlineBrTarget
+				}
+				case 0x32:
+				{
+					return OpCodes.Blt_S; // blt.s ShortInlineBrTarget
+				}
+				case 0x33:
+				{
+					return OpCodes.Bne_Un_S; // bne.un.s ShortInlineBrTarget
+				}
+				case 0x34:
+				{
+					return OpCodes.Bge_Un_S; // bge.un.s ShortInlineBrTarget
+				}
+				case 0x35:
+				{
+					return OpCodes.Bgt_Un_S; // bgt.un.s ShortInlineBrTarget
+				}
+				case 0x36:
+				{
+					return OpCodes.Ble_Un_S; // ble.un.s ShortInlineBrTarget
+				}
+				case 0x37:
+				{
+					return OpCodes.Blt_Un_S; // blt.un.s ShortInlineBrTarget
+				}
+				case 0x38:
+				{
+					return OpCodes.Br; // br InlineBrTarget
+				}
+				case 0x39:
+				{
+					return OpCodes.Brfalse; // brfalse InlineBrTarget
+				}
+				case 0x3A:
+				{
+					return OpCodes.Brtrue; // brtrue InlineBrTarget
+				}
+				case 0x3B:
+				{
+					return OpCodes.Beq; // beq InlineBrTarget
+				}
+				case 0x3C:
+				{
+					return OpCodes.Bge; // bge InlineBrTarget
+				}
+				case 0x3D:
+				{
+					return OpCodes.Bgt; // bgt InlineBrTarget
+				}
+				case 0x3E:
+				{
+					return OpCodes.Ble; // ble InlineBrTarget
+				}
+				case 0x3F:
+				{
+					return OpCodes.Blt; // blt InlineBrTarget
+				}
+				case 0x40:
+				{
+					return OpCodes.Bne_Un; // bne.un InlineBrTarget
+				}
+				case 0x41:
+				{
+					return OpCodes.Bge_Un; // bge.un InlineBrTarget
+				}
+				case 0x42:
+				{
+					return OpCodes.Bgt_Un; // bgt.un InlineBrTarget
+				}
+				case 0x43:
+				{
+					return OpCodes.Ble_Un; // ble.un InlineBrTarget
+				}
+				case 0x44:
+				{
+					return OpCodes.Blt_Un; // blt.un InlineBrTarget
+				}
+				case 0x45:
+				{
+					return OpCodes.Switch; // switch InlineSwitch
+				}
+				case 0x46:
+				{
+					return OpCodes.Ldind_I1; // ldind.i1 InlineNone
+				}
+				case 0x47:
+				{
+					return OpCodes.Ldind_U1; // ldind.u1 InlineNone
+				}
+				case 0x48:
+				{
+					return OpCodes.Ldind_I2; // ldind.i2 InlineNone
+				}
+				case 0x49:
+				{
+					return OpCodes.Ldind_U2; // ldind.u2 InlineNone
+				}
+				case 0x4A:
+				{
+					return OpCodes.Ldind_I4; // ldind.i4 InlineNone
+				}
+				case 0x4B:
+				{
+					return OpCodes.Ldind_U4; // ldind.u4 InlineNone
+				}
+				case 0x4C:
+				{
+					return OpCodes.Ldind_I8; // ldind.i8 InlineNone
+				}
+				case 0x4D:
+				{
+					return OpCodes.Ldind_I; // ldind.i InlineNone
+				}
+				case 0x4E:
+				{
+					return OpCodes.Ldind_R4; // ldind.r4 InlineNone
+				}
+				case 0x4F:
+				{
+					return OpCodes.Ldind_R8; // ldind.r8 InlineNone
+				}
+				case 0x50:
+				{
+					return OpCodes.Ldind_Ref; // ldind.ref InlineNone
+				}
+				case 0x51:
+				{
+					return OpCodes.Stind_Ref; // stind.ref InlineNone
+				}
+				case 0x52:
+				{
+					return OpCodes.Stind_I1; // stind.i1 InlineNone
+				}
+				case 0x53:
+				{
+					return OpCodes.Stind_I2; // stind.i2 InlineNone
+				}
+				case 0x54:
+				{
+					return OpCodes.Stind_I4; // stind.i4 InlineNone
+				}
+				case 0x55:
+				{
+					return OpCodes.Stind_I8; // stind.i8 InlineNone
+				}
+				case 0x56:
+				{
+					return OpCodes.Stind_R4; // stind.r4 InlineNone
+				}
+				case 0x57:
+				{
+					return OpCodes.Stind_R8; // stind.r8 InlineNone
+				}
+				case 0x58:
+				{
+					return OpCodes.Add; // add InlineNone
+				}
+				case 0x59:
+				{
+					return OpCodes.Sub; // sub InlineNone
+				}
+				case 0x5A:
+				{
+					return OpCodes.Mul; // mul InlineNone
+				}
+				case 0x5B:
+				{
+					return OpCodes.Div; // div InlineNone
+				}
+				case 0x5C:
+				{
+					return OpCodes.Div_Un; // div.un InlineNone
+				}
+				case 0x5D:
+				{
+					return OpCodes.Rem; // rem InlineNone
+				}
+				case 0x5E:
+				{
+					return OpCodes.Rem_Un; // rem.un InlineNone
+				}
+				case 0x5F:
+				{
+					return OpCodes.And; // and InlineNone
+				}
+				case 0x60:
+				{
+					return OpCodes.Or; // or InlineNone
+				}
+				case 0x61:
+				{
+					return OpCodes.Xor; // xor InlineNone
+				}
+				case 0x62:
+				{
+					return OpCodes.Shl; // shl InlineNone
+				}
+				case 0x63:
+				{
+					return OpCodes.Shr; // shr InlineNone
+				}
+				case 0x64:
+				{
+					return OpCodes.Shr_Un; // shr.un InlineNone
+				}
+				case 0x65:
+				{
+					return OpCodes.Neg; // neg InlineNone
+				}
+				case 0x66:
+				{
+					return OpCodes.Not; // not InlineNone
+				}
+				case 0x67:
+				{
+					return OpCodes.Conv_I1; // conv.i1 InlineNone
+				}
+				case 0x68:
+				{
+					return OpCodes.Conv_I2; // conv.i2 InlineNone
+				}
+				case 0x69:
+				{
+					return OpCodes.Conv_I4; // conv.i4 InlineNone
+				}
+				case 0x6A:
+				{
+					return OpCodes.Conv_I8; // conv.i8 InlineNone
+				}
+				case 0x6B:
+				{
+					return OpCodes.Conv_R4; // conv.r4 InlineNone
+				}
+				case 0x6C:
+				{
+					return OpCodes.Conv_R8; // conv.r8 InlineNone
+				}
+				case 0x6D:
+				{
+					return OpCodes.Conv_U4; // conv.u4 InlineNone
+				}
+				case 0x6E:
+				{
+					return OpCodes.Conv_U8; // conv.u8 InlineNone
+				}
+				case 0x6F:
+				{
+					return OpCodes.Callvirt; // callvirt InlineMethod
+				}
+				case 0x70:
+				{
+					return OpCodes.Cpobj; // cpobj InlineType
+				}
+				case 0x71:
+				{
+					return OpCodes.Ldobj; // ldobj InlineType
+				}
+				case 0x72:
+				{
+					return OpCodes.Ldstr; // ldstr InlineString
+				}
+				case 0x73:
+				{
+					return OpCodes.Newobj; // newobj InlineMethod
+				}
+				case 0x74:
+				{
+					return OpCodes.Castclass; // castclass InlineType
+				}
+				case 0x75:
+				{
+					return OpCodes.Isinst; // isinst InlineType
+				}
+				case 0x76:
+				{
+					return OpCodes.Conv_R_Un; // conv.r.un InlineNone
+				}
+				case 0x79:
+				{
+					return OpCodes.Unbox; // unbox InlineType
+				}
+				case 0x7A:
+				{
+					return OpCodes.Throw; // throw InlineNone
+				}
+				case 0x7B:
+				{
+					return OpCodes.Ldfld; // ldfld InlineField
+				}
+				case 0x7C:
+				{
+					return OpCodes.Ldflda; // ldflda InlineField
+				}
+				case 0x7D:
+				{
+					return OpCodes.Stfld; // stfld InlineField
+				}
+				case 0x7E:
+				{
+					return OpCodes.Ldsfld; // ldsfld InlineField
+				}
+				case 0x7F:
+				{
+					return OpCodes.Ldsflda; // ldsflda InlineField
+				}
+				case 0x80:
+				{
+					return OpCodes.Stsfld; // stsfld InlineField
+				}
+				case 0x81:
+				{
+					return OpCodes.Stobj; // stobj InlineType
+				}
+				case 0x82:
+				{
+					return OpCodes.Conv_Ovf_I1_Un; // conv.ovf.i1.un InlineNone
+				}
+				case 0x83:
+				{
+					return OpCodes.Conv_Ovf_I2_Un; // conv.ovf.i2.un InlineNone
+				}
+				case 0x84:
+				{
+					return OpCodes.Conv_Ovf_I4_Un; // conv.ovf.i4.un InlineNone
+				}
+				case 0x85:
+				{
+					return OpCodes.Conv_Ovf_I8_Un; // conv.ovf.i8.un InlineNone
+				}
+				case 0x86:
+				{
+					return OpCodes.Conv_Ovf_U1_Un; // conv.ovf.u1.un InlineNone
+				}
+				case 0x87:
+				{
+					return OpCodes.Conv_Ovf_U2_Un; // conv.ovf.u2.un InlineNone
+				}
+				case 0x88:
+				{
+					return OpCodes.Conv_Ovf_U4_Un; // conv.ovf.u4.un InlineNone
+				}
+				case 0x89:
+				{
+					return OpCodes.Conv_Ovf_U8_Un; // conv.ovf.u8.un InlineNone
+				}
+				case 0x8A:
+				{
+					return OpCodes.Conv_Ovf_I_Un; // conv.ovf.i.un InlineNone
+				}
+				case 0x8B:
+				{
+					return OpCodes.Conv_Ovf_U_Un; // conv.ovf.u.un InlineNone
+				}
+				case 0x8C:
+				{
+					return OpCodes.Box; // box InlineType
+				}
+				case 0x8D:
+				{
+					return OpCodes.Newarr; // newarr InlineType
+				}
+				case 0x8E:
+				{
+					return OpCodes.Ldlen; // ldlen InlineNone
+				}
+				case 0x8F:
+				{
+					return OpCodes.Ldelema; // ldelema InlineType
+				}
+				case 0x90:
+				{
+					return OpCodes.Ldelem_I1; // ldelem.i1 InlineNone
+				}
+				case 0x91:
+				{
+					return OpCodes.Ldelem_U1; // ldelem.u1 InlineNone
+				}
+				case 0x92:
+				{
+					return OpCodes.Ldelem_I2; // ldelem.i2 InlineNone
+				}
+				case 0x93:
+				{
+					return OpCodes.Ldelem_U2; // ldelem.u2 InlineNone
+				}
+				case 0x94:
+				{
+					return OpCodes.Ldelem_I4; // ldelem.i4 InlineNone
+				}
+				case 0x95:
+				{
+					return OpCodes.Ldelem_U4; // ldelem.u4 InlineNone
+				}
+				case 0x96:
+				{
+					return OpCodes.Ldelem_I8; // ldelem.i8 InlineNone
+				}
+				case 0x97:
+				{
+					return OpCodes.Ldelem_I; // ldelem.i InlineNone
+				}
+				case 0x98:
+				{
+					return OpCodes.Ldelem_R4; // ldelem.r4 InlineNone
+				}
+				case 0x99:
+				{
+					return OpCodes.Ldelem_R8; // ldelem.r8 InlineNone
+				}
+				case 0x9A:
+				{
+					return OpCodes.Ldelem_Ref; // ldelem.ref InlineNone
+				}
+				case 0x9B:
+				{
+					return OpCodes.Stelem_I; // stelem.i InlineNone
+				}
+				case 0x9C:
+				{
+					return OpCodes.Stelem_I1; // stelem.i1 InlineNone
+				}
+				case 0x9D:
+				{
+					return OpCodes.Stelem_I2; // stelem.i2 InlineNone
+				}
+				case 0x9E:
+				{
+					return OpCodes.Stelem_I4; // stelem.i4 InlineNone
+				}
+				case 0x9F:
+				{
+					return OpCodes.Stelem_I8; // stelem.i8 InlineNone
+				}
+				case 0xA0:
+				{
+					return OpCodes.Stelem_R4; // stelem.r4 InlineNone
+				}
+				case 0xA1:
+				{
+					return OpCodes.Stelem_R8; // stelem.r8 InlineNone
+				}
+				case 0xA2:
+				{
+					return OpCodes.Stelem_Ref; // stelem.ref InlineNone
+				}
+				case 0xA3:
+				{
+					return OpCodes.Ldelem; // ldelem InlineType
+				}
+				case 0xA4:
+				{
+					return OpCodes.Stelem; // stelem InlineType
+				}
+				case 0xA5:
+				{
+					return OpCodes.Unbox_Any; // unbox.any InlineType
+				}
+				case 0xB3:
+				{
+					return OpCodes.Conv_Ovf_I1; // conv.ovf.i1 InlineNone
+				}
+				case 0xB4:
+				{
+					return OpCodes.Conv_Ovf_U1; // conv.ovf.u1 InlineNone
+				}
+				case 0xB5:
+				{
+					return OpCodes.Conv_Ovf_I2; // conv.ovf.i2 InlineNone
+				}
+				case 0xB6:
+				{
+					return OpCodes.Conv_Ovf_U2; // conv.ovf.u2 InlineNone
+				}
+				case 0xB7:
+				{
+					return OpCodes.Conv_Ovf_I4; // conv.ovf.i4 InlineNone
+				}
+				case 0xB8:
+				{
+					return OpCodes.Conv_Ovf_U4; // conv.ovf.u4 InlineNone
+				}
+				case 0xB9:
+				{
+					return OpCodes.Conv_Ovf_I8; // conv.ovf.i8 InlineNone
+				}
+				case 0xBA:
+				{
+					return OpCodes.Conv_Ovf_U8; // conv.ovf.u8 InlineNone
+				}
+				case 0xC2:
+				{
+					return OpCodes.Refanyval; // refanyval InlineType
+				}
+				case 0xC3:
+				{
+					return OpCodes.Ckfinite; // ckfinite InlineNone
+				}
+				case 0xC6:
+				{
+					return OpCodes.Mkrefany; // mkrefany InlineType
+				}
+				case 0xD0:
+				{
+					return OpCodes.Ldtoken; // ldtoken InlineTok
+				}
+				case 0xD1:
+				{
+					return OpCodes.Conv_U2; // conv.u2 InlineNone
+				}
+				case 0xD2:
+				{
+					return OpCodes.Conv_U1; // conv.u1 InlineNone
+				}
+				case 0xD3:
+				{
+					return OpCodes.Conv_I; // conv.i InlineNone
+				}
+				case 0xD4:
+				{
+					return OpCodes.Conv_Ovf_I; // conv.ovf.i InlineNone
+				}
+				case 0xD5:
+				{
+					return OpCodes.Conv_Ovf_U; // conv.ovf.u InlineNone
+				}
+				case 0xD6:
+				{
+					return OpCodes.Add_Ovf; // add.ovf InlineNone
+				}
+				case 0xD7:
+				{
+					return OpCodes.Add_Ovf_Un; // add.ovf.un InlineNone
+				}
+				case 0xD8:
+				{
+					return OpCodes.Mul_Ovf; // mul.ovf InlineNone
+				}
+				case 0xD9:
+				{
+					return OpCodes.Mul_Ovf_Un; // mul.ovf.un InlineNone
+				}
+				case 0xDA:
+				{
+					return OpCodes.Sub_Ovf; // sub.ovf InlineNone
+				}
+				case 0xDB:
+				{
+					return OpCodes.Sub_Ovf_Un; // sub.ovf.un InlineNone
+				}
+				case 0xDC:
+				{
+					return OpCodes.Endfinally; // endfinally InlineNone
+				}
+				case 0xDD:
+				{
+					return OpCodes.Leave; // leave InlineBrTarget
+				}
+				case 0xDE:
+				{
+					return OpCodes.Leave_S; // leave.s ShortInlineBrTarget
+				}
+				case 0xDF:
+				{
+					return OpCodes.Stind_I; // stind.i InlineNone
+				}
+				case 0xE0:
+				{
+					return OpCodes.Conv_U; // conv.u InlineNone
+				}
+				default:
+				{
+					var opCode = BinaryPrimitives.ReadUInt16BigEndian(il);
+					switch (opCode)
+					{
+						case 0xFE00:
+						{
+							return OpCodes.Arglist; // arglist InlineNone
+						}
+						case 0xFE01:
+						{
+							return OpCodes.Ceq; // ceq InlineNone
+						}
+						case 0xFE02:
+						{
+							return OpCodes.Cgt; // cgt InlineNone
+						}
+						case 0xFE03:
+						{
+							return OpCodes.Cgt_Un; // cgt.un InlineNone
+						}
+						case 0xFE04:
+						{
+							return OpCodes.Clt; // clt InlineNone
+						}
+						case 0xFE05:
+						{
+							return OpCodes.Clt_Un; // clt.un InlineNone
+						}
+						case 0xFE06:
+						{
+							return OpCodes.Ldftn; // ldftn InlineMethod
+						}
+						case 0xFE07:
+						{
+							return OpCodes.Ldvirtftn; // ldvirtftn InlineMethod
+						}
+						case 0xFE09:
+						{
+							return OpCodes.Ldarg; // ldarg InlineVar
+						}
+						case 0xFE0A:
+						{
+							return OpCodes.Ldarga; // ldarga InlineVar
+						}
+						case 0xFE0B:
+						{
+							return OpCodes.Starg; // starg InlineVar
+						}
+						case 0xFE0C:
+						{
+							return OpCodes.Ldloc; // ldloc InlineVar
+						}
+						case 0xFE0D:
+						{
+							return OpCodes.Ldloca; // ldloca InlineVar
+						}
+						case 0xFE0E:
+						{
+							return OpCodes.Stloc; // stloc InlineVar
+						}
+						case 0xFE0F:
+						{
+							return OpCodes.Localloc; // localloc InlineNone
+						}
+						case 0xFE11:
+						{
+							return OpCodes.Endfilter; // endfilter InlineNone
+						}
+						case 0xFE12:
+						{
+							return OpCodes.Unaligned; // unaligned. ShortInlineI
+						}
+						case 0xFE13:
+						{
+							return OpCodes.Volatile; // volatile. InlineNone
+						}
+						case 0xFE14:
+						{
+							return OpCodes.Tailcall; // tail. InlineNone
+						}
+						case 0xFE15:
+						{
+							return OpCodes.Initobj; // initobj InlineType
+						}
+						case 0xFE16:
+						{
+							return OpCodes.Constrained; // constrained. InlineType
+						}
+						case 0xFE17:
+						{
+							return OpCodes.Cpblk; // cpblk InlineNone
+						}
+						case 0xFE18:
+						{
+							return OpCodes.Initblk; // initblk InlineNone
+						}
+						case 0xFE1A:
+						{
+							return OpCodes.Rethrow; // rethrow InlineNone
+						}
+						case 0xFE1C:
+						{
+							return OpCodes.Sizeof; // sizeof InlineType
+						}
+						case 0xFE1D:
+						{
+							return OpCodes.Refanytype; // refanytype InlineNone
+						}
+						case 0xFE1E:
+						{
+							return OpCodes.Readonly; // readonly. InlineNone
+						}
+						default:
+						{
+							throw new Exception($"Unknown opcode 0x{opCode}.");
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.tt b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.tt
new file mode 100644
index 000000000..36c108a0e
--- /dev/null
+++ b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranslator.Parse.tt
@@ -0,0 +1,82 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Reflection" #>
+<#@ import namespace="System.Reflection.Emit" #>
+<#@ output extension=".cs" #>
+<#
+var opCodes = typeof(OpCodes).GetFields(BindingFlags.Public | BindingFlags.Static).Select(f => (OpCode)f.GetValue(null)).ToArray();
+var opCode1Bytes = opCodes.Where(o => o.Value >= 0 && !o.Name.StartsWith("prefix")).ToArray();
+var opCode2Bytes = opCodes.Where(o => o.Value < 0).ToArray();
+#>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Buffers.Binary;
+using System.Reflection.Emit;
+
+namespace MsgPack.Serialization.Reflection
+{
+	partial class ILTranspiler
+	{
+		private static OpCode Parse(Span<byte> il)
+		{
+			switch(il[0])
+			{
+<#
+foreach (var opCode in opCode1Bytes)
+{
+#>
+				case 0x<#= opCode.Value.ToString("X2") #>:
+				{
+					return OpCodes.<#= Pascalize(opCode.Name) #>; // <#= opCode.Name #> <#= opCode.OperandType #>
+				}
+<#
+}
+#>
+				default:
+				{
+					var opCode = BinaryPrimitives.ReadUInt16BigEndian(il);
+					switch (opCode)
+					{
+<#
+foreach (var opCode in opCode2Bytes)
+{
+#>
+						case 0x<#= opCode.Value.ToString("X4") #>:
+						{
+							return OpCodes.<#= Pascalize(opCode.Name) #>; // <#= opCode.Name #> <#= opCode.OperandType #>
+						}
+<#
+}
+#>
+						default:
+						{
+							throw new Exception($"Unknown opcode 0x{opCode}.");
+						}
+					}
+				}
+			}
+		}
+	}
+}
+<#+
+static readonly char[] SplitDelimiters = { '.' };
+static readonly Dictionary<string, string> OpCodeNameMap =
+	new Dictionary<string, string>
+	{
+		["tail."] = "Tailcall",
+	};
+
+string Pascalize(string name)
+	=> OpCodeNameMap.TryGetValue(name, out var mapped) ?
+		mapped :
+		String.Join("_", name.Split(SplitDelimiters, StringSplitOptions.RemoveEmptyEntries).Select(n => Char.ToUpperInvariant(n[0]) + n.Substring(1)));
+#>
diff --git a/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranspiler.cs b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranspiler.cs
new file mode 100644
index 000000000..ca208fbad
--- /dev/null
+++ b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/ILTranspiler.cs
@@ -0,0 +1,308 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace MsgPack.Serialization.Reflection
+{
+	/// <summary>
+	///		Defines IL transpilation logics.
+	/// </summary>
+	internal static partial class ILTranspiler
+	{
+		/// <summary>
+		///		Ports specified method IL instructions to the specified <see cref="ILGenerator"/> in context of specified <see cref="ILGenerationContext"/>.
+		/// </summary>
+		/// <param name="context">A context for current code generation.</param>
+		/// <param name="source">Real <see cref="MethodBase"/> which contains IL source.</param>
+		/// <param name="destination"><see cref="ILGenerator"/> which will be emitted ported IL instructions.</param>
+		public static void Port(ILGenerationContext context, MethodBase source, ILGenerator destination)
+		{
+			var methodBody = source.GetMethodBody();
+			if (methodBody == null)
+			{
+				throw new ArgumentException($"The method {source} does not have method body.", nameof(source));
+			}
+
+			var tries = methodBody.ExceptionHandlingClauses.ToLookup(e => e.TryOffset);
+			var filters = methodBody.ExceptionHandlingClauses.ToLookup(e => e.FilterOffset);
+			var handlers = methodBody.ExceptionHandlingClauses.ToLookup(e => e.HandlerOffset);
+			var endClauses = methodBody.ExceptionHandlingClauses.ToLookup(e => e.HandlerOffset);
+
+			var locals = methodBody.LocalVariables.OrderBy(l => l.LocalIndex).Select(l => destination.DeclareLocal(l.LocalType, l.IsPinned)).ToArray();
+			var labels = new Dictionary<int, List<Label>>();
+
+			var ilStream = methodBody.GetILAsByteArray()!.AsSpan();
+			var emits = new List<(int Offset, List<Action<ILGenerator>> Emitters)>();
+
+			// Scan
+			ParseILStream(context, source, destination, locals, labels, ilStream, emits);
+
+			// Real emit
+			EmitILStream(destination, tries, filters, handlers, endClauses, labels, emits);
+		}
+
+		private static void ParseILStream(ILGenerationContext context, MethodBase source, ILGenerator destination, LocalBuilder[] locals, Dictionary<int, List<Label>> labels, Span<byte> ilStream, List<(int Offset, List<Action<ILGenerator>> Emitters)> emits)
+		{
+			var offset = 0;
+			while (offset < ilStream.Length)
+			{
+				var currentOffset = offset;
+				var currentEmits = new List<Action<ILGenerator>>();
+
+				var opCode = Parse(ilStream);
+				ilStream = ilStream.Slice(1);
+				offset++;
+				switch (opCode.OperandType)
+				{
+					case OperandType.InlineBrTarget:
+					{
+						var branchOffset = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						var label = destination.DefineLabel();
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						AddLabel(labels, branchOffset + offset, label);
+						currentEmits.Add(il => il.Emit(opCode, label));
+						break;
+					}
+					case OperandType.InlineField:
+					{
+						var token = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						var field = context.ResolveField(source, token);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						currentEmits.Add(il => il.Emit(opCode, field!));
+						break;
+					}
+					case OperandType.InlineI:
+					{
+						var immediate = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						currentEmits.Add(il => il.Emit(opCode, immediate));
+						break;
+					}
+					case OperandType.InlineI8:
+					{
+						var immediate = BinaryPrimitives.ReadInt64LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(long));
+						offset += sizeof(long);
+						currentEmits.Add(il => il.Emit(opCode, immediate));
+						break;
+					}
+					case OperandType.InlineMethod:
+					{
+						var token = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+
+						if (opCode == OpCodes.Call || opCode == OpCodes.Callvirt)
+						{
+							var method = context.ResolveMethod(source, token);
+							currentEmits.Add(il => il.EmitCall(opCode, method, null));
+						}
+						else if (opCode == OpCodes.Newobj)
+						{
+							var constructor = context.ResolveConstructor(source, token);
+							currentEmits.Add(il => il.Emit(opCode, constructor));
+						}
+						else if (opCode == OpCodes.Ldftn || opCode == OpCodes.Ldvirtftn || opCode == OpCodes.Jmp)
+						{
+							var method = context.ResolveMethod(source, token);
+							currentEmits.Add(il => il.Emit(opCode, method));
+						}
+						else
+						{
+							throw new NotSupportedException($"Unknown opcode '{opCode.Name}'(0x{opCode.Value:X}) at offset {offset}.");
+						}
+
+						break;
+					}
+					case OperandType.InlineNone:
+					{
+						currentEmits.Add(il => il.Emit(opCode));
+						break;
+					}
+					case OperandType.InlineR:
+					{
+						var immediate = BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(ilStream));
+						ilStream = ilStream.Slice(sizeof(long));
+						offset += sizeof(long);
+						currentEmits.Add(il => il.Emit(opCode, immediate));
+						break;
+					}
+					case OperandType.InlineSig:
+					{
+						throw new NotImplementedException($"OpCode '{opCode.Name}' at offset {offset} in {source} is not implemented.");
+					}
+					case OperandType.InlineString:
+					{
+						var token = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						var literal = source.Module.ResolveString(token);
+						currentEmits.Add(il => il.Emit(opCode, literal));
+						break;
+					}
+					case OperandType.InlineSwitch:
+					{
+						var caseCount = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+
+						var caseLabels = new List<Label>(caseCount);
+						var caseBaseOffset = offset + (caseCount * sizeof(int));
+						for (var i = 0; i < caseLabels.Count; i++)
+						{
+							var caseTarget = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+							ilStream = ilStream.Slice(sizeof(int));
+							offset += sizeof(int);
+							var label = destination.DefineLabel();
+							caseLabels.Add(label);
+							AddLabel(labels, caseTarget + caseBaseOffset, label);
+						}
+
+						currentEmits.Add(il => il.Emit(opCode, caseLabels.ToArray()));
+						break;
+					}
+					case OperandType.InlineTok:
+					{
+						var token = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						currentEmits.Add(il => il.Emit(opCode, token));
+						break;
+					}
+					case OperandType.InlineType:
+					{
+						var token = BinaryPrimitives.ReadInt32LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						var type = context.ResolveType(source, token);
+						currentEmits.Add(il => il.Emit(opCode, type));
+						break;
+					}
+					case OperandType.InlineVar:
+					{
+						var index = BinaryPrimitives.ReadUInt16LittleEndian(ilStream);
+						ilStream = ilStream.Slice(sizeof(ushort));
+						offset += sizeof(ushort);
+						var local = locals[index];
+						currentEmits.Add(il => il.Emit(opCode, local));
+						break;
+					}
+					case OperandType.ShortInlineBrTarget:
+					{
+						var branchOffset = (sbyte)ilStream[0];
+						var label = destination.DefineLabel();
+						ilStream = ilStream.Slice(sizeof(sbyte));
+						offset += sizeof(sbyte);
+						AddLabel(labels, branchOffset + offset, label);
+						currentEmits.Add(il => il.Emit(opCode, label));
+						break;
+					}
+					case OperandType.ShortInlineI:
+					{
+						var immediate = (sbyte)ilStream[0];
+						ilStream = ilStream.Slice(sizeof(sbyte));
+						offset += sizeof(sbyte);
+						currentEmits.Add(il => il.Emit(opCode, immediate));
+						break;
+					}
+					case OperandType.ShortInlineR:
+					{
+						var immediate = BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(ilStream));
+						ilStream = ilStream.Slice(sizeof(int));
+						offset += sizeof(int);
+						currentEmits.Add(il => il.Emit(opCode, immediate));
+						break;
+					}
+					case OperandType.ShortInlineVar:
+					{
+						var index = ilStream[0];
+						ilStream = ilStream.Slice(sizeof(byte));
+						offset += sizeof(byte);
+						var local = locals[index];
+						currentEmits.Add(il => il.Emit(opCode, local));
+						break;
+					}
+					default:
+					{
+						throw new NotSupportedException($"Unknown operand type {opCode.OperandType}({opCode.OperandType:D}) for opcode '{opCode.Name}' at offset {offset}.");
+					}
+				} // switch
+
+				emits.Add((currentOffset, currentEmits));
+			} // while
+		}
+
+		private static void EmitILStream(ILGenerator destination, ILookup<int, ExceptionHandlingClause> tries, ILookup<int, ExceptionHandlingClause> filters, ILookup<int, ExceptionHandlingClause> handlers, ILookup<int, ExceptionHandlingClause> endClauses, Dictionary<int, List<Label>> labels, List<(int Offset, List<Action<ILGenerator>> Emitters)> emits)
+		{
+			foreach (var emit in emits)
+			{
+				if (labels.TryGetValue(emit.Offset, out var labelList))
+				{
+					foreach (var label in labelList)
+					{
+						destination.MarkLabel(label);
+					}
+				}
+
+				foreach (var @try in tries[emit.Offset])
+				{
+					destination.BeginExceptionBlock();
+				}
+
+				foreach (var filter in filters[emit.Offset])
+				{
+					destination.BeginExceptFilterBlock();
+				}
+
+				foreach (var handler in handlers[emit.Offset])
+				{
+					if (handler.Flags == ExceptionHandlingClauseOptions.Clause)
+					{
+						destination.BeginCatchBlock(handler.CatchType ?? typeof(object));
+					}
+
+					if ((handler.Flags & ExceptionHandlingClauseOptions.Fault) != 0)
+					{
+						destination.BeginFaultBlock();
+					}
+
+					if ((handler.Flags & ExceptionHandlingClauseOptions.Finally) != 0)
+					{
+						destination.BeginFaultBlock();
+					}
+				}
+
+				foreach (var endClause in endClauses[emit.Offset])
+				{
+					destination.EndExceptionBlock();
+				}
+
+				foreach (var emitter in emit.Emitters)
+				{
+					emitter(destination);
+				}
+			}
+		}
+
+		private static void AddLabel(Dictionary<int, List<Label>> labels, int offset, Label label)
+		{
+			if(!labels.TryGetValue(offset, out var labelList))
+			{
+				labelList = new List<Label>();
+				labels[offset] = labelList;
+			}
+
+			labelList.Add(label);
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/MethodSignature.cs b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/MethodSignature.cs
new file mode 100644
index 000000000..9bc95d542
--- /dev/null
+++ b/src/MsgPack.Serialization.ILGeneration/Serialization/Reflection/MethodSignature.cs
@@ -0,0 +1,43 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace MsgPack.Serialization.Reflection
+{
+	internal struct MethodSignature : IEquatable<MethodSignature>
+	{
+		public string Name { get; }
+		public IReadOnlyList<string> ParameterTypes { get; }
+
+		public MethodSignature(MethodBase method)
+		{
+			this.Name = method.Name;
+			this.ParameterTypes = method.GetParameters().Select(p => p.ParameterType.ToString()).ToArray();
+		}
+
+		public bool Equals(MethodSignature other)
+			=> this.Name == other.Name
+				&& this.ParameterTypes.Count == other.ParameterTypes.Count
+				&& this.ParameterTypes.SequenceEqual(other.ParameterTypes, StringComparer.Ordinal);
+
+		public override bool Equals(object? obj)
+			=> (obj is MethodSignature other) ? this.Equals(other) : false;
+
+		public override int GetHashCode()
+		{
+			var hashCode = new HashCode();
+			hashCode.Add(this.Name);
+			foreach(var parameterType in this.ParameterTypes)
+			{
+				hashCode.Add(parameterType);
+			}
+
+			return hashCode.ToHashCode();
+		}
+	}
+}

From 2c8530f36f6adb81763ad3634da41f44d99ab938 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 14 Jul 2020 21:30:27 +0900
Subject: [PATCH 40/82] Port StringBuilderCache from .NET Core

---
 .../System.Text/StringBuilderCache.cs         | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 src/MsgPack.Abstraction/System.Text/StringBuilderCache.cs

diff --git a/src/MsgPack.Abstraction/System.Text/StringBuilderCache.cs b/src/MsgPack.Abstraction/System.Text/StringBuilderCache.cs
new file mode 100644
index 000000000..bf50a5cee
--- /dev/null
+++ b/src/MsgPack.Abstraction/System.Text/StringBuilderCache.cs
@@ -0,0 +1,63 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+namespace System.Text
+{
+	/// <summary>Provide a cached reusable instance of stringbuilder per thread.</summary>
+	internal static class StringBuilderCache
+	{
+		// The value 360 was chosen in discussion with performance experts as a compromise between using
+		// as litle memory per thread as possible and still covering a large part of short-lived
+		// StringBuilder creations on the startup path of VS designers.
+		internal const int MaxBuilderSize = 360;
+		private const int DefaultCapacity = 16; // == StringBuilder.DefaultCapacity
+
+		// WARNING: We allow diagnostic tools to directly inspect this member (t_cachedInstance).
+		// See https://github.com/dotnet/corert/blob/master/Documentation/design-docs/diagnostics/diagnostics-tools-contract.md for more details.
+		// Please do not change the type, the name, or the semantic usage of this member without understanding the implication for tools.
+		// Get in touch with the diagnostics team if you have questions.
+		[ThreadStatic]
+		private static StringBuilder? t_cachedInstance;
+
+		/// <summary>Get a StringBuilder for the specified capacity.</summary>
+		/// <remarks>If a StringBuilder of an appropriate size is cached, it will be returned and the cache emptied.</remarks>
+		public static StringBuilder Acquire(int capacity = DefaultCapacity)
+		{
+			if (capacity <= MaxBuilderSize)
+			{
+				StringBuilder? sb = t_cachedInstance;
+				if (sb != null)
+				{
+					// Avoid stringbuilder block fragmentation by getting a new StringBuilder
+					// when the requested size is larger than the current capacity
+					if (capacity <= sb.Capacity)
+					{
+						t_cachedInstance = null;
+						sb.Clear();
+						return sb;
+					}
+				}
+			}
+
+			return new StringBuilder(capacity);
+		}
+
+		/// <summary>Place the specified builder in the cache if it is not too big.</summary>
+		public static void Release(StringBuilder sb)
+		{
+			if (sb.Capacity <= MaxBuilderSize)
+			{
+				t_cachedInstance = sb;
+			}
+		}
+
+		/// <summary>ToString() the stringbuilder, Release it to the cache, and return the resulting string.</summary>
+		public static string GetStringAndRelease(StringBuilder sb)
+		{
+			string result = sb.ToString();
+			Release(sb);
+			return result;
+		}
+	}
+}

From 7e6f71ccbb82dc7fd66392526c47e4cce7b9fa27 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Tue, 14 Jul 2020 21:34:07 +0900
Subject: [PATCH 41/82] Port FarmHash

This port utilizes x86 intrinsics for performance.
In development environment (Core i7 8070), NA (with SSE4.1 and x64 process) mode is about 175% faster than MT (without any intrinsics) for 16B array, and is about 257% faster for 1kiB array.
---
 .../Internal/FarmHash.MK.cs                   | 160 +++++++++
 .../Internal/FarmHash.NA.cs                   | 246 ++++++++++++++
 .../Internal/FarmHash.NT.cs                   |  47 +++
 .../Internal/FarmHash.SA.cs                   | 277 ++++++++++++++++
 .../Internal/FarmHash.SU.cs                   | 304 ++++++++++++++++++
 .../Internal/FarmHash.TE.cs                   | 264 +++++++++++++++
 .../Internal/FarmHash.UO.cs                   | 163 ++++++++++
 .../Internal/FarmHash.XO.cs                   | 112 +++++++
 src/MsgPack.Abstraction/Internal/FarmHash.cs  | 164 ++++++++++
 9 files changed, 1737 insertions(+)
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.MK.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.NT.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.TE.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.XO.cs
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.cs

diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs b/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs
new file mode 100644
index 000000000..f015478d8
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs
@@ -0,0 +1,160 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		internal static class MK
+		{
+			internal static unsafe uint Hash32Len13to24(byte* s, uint len, uint seed = 0)
+			{
+				uint a = Fetch32(s - 4 + (len >> 1));
+				uint b = Fetch32(s + 4);
+				uint c = Fetch32(s + len - 8);
+				uint d = Fetch32(s + (len >> 1));
+				uint e = Fetch32(s);
+				uint f = Fetch32(s + len - 4);
+				uint h = d * c1 + len + seed;
+				a = Rotate32(a, 12) + f;
+				h = Mur(c, h) + a;
+				a = Rotate32(a, 3) + c;
+				h = Mur(e, h) + a;
+				a = Rotate32(a + f, 12) + d;
+				h = Mur(b ^ seed, h) + a;
+				return fmix(h);
+			}
+
+			internal static unsafe uint Hash32Len0to4(byte* s, uint len, uint seed = 0)
+			{
+				uint b = seed;
+				uint c = 9;
+				for (var i = 0; i < len; i++)
+				{
+					var v = s[i];
+					b = b * c1 + v;
+					c ^= b;
+				}
+				return fmix(Mur(b, Mur(len, c)));
+			}
+
+			internal static unsafe uint Hash32Len5to12(byte* s, uint len, uint seed = 0)
+			{
+				uint a = len, b = len * 5, c = 9, d = b + seed;
+				a += Fetch32(s);
+				b += Fetch32(s + len - 4);
+				c += Fetch32(s + ((len >> 1) & 4));
+				return fmix(seed ^ Mur(c, Mur(b, Mur(a, d))));
+			}
+
+			public static unsafe uint Hash32(byte* s, uint len)
+			{
+				if (len <= 24)
+				{
+					return len <= 12 ?
+						(len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len)) :
+						Hash32Len13to24(s, len);
+				}
+
+				// len > 24
+				uint h = len, g = c1 * len, f = g;
+				uint a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2;
+				uint a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2;
+				uint a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2;
+				uint a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2;
+				uint a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2;
+				h ^= a0;
+				h = Rotate32(h, 19);
+				h = h * 5 + 0xe6546b64;
+				h ^= a2;
+				h = Rotate32(h, 19);
+				h = h * 5 + 0xe6546b64;
+				g ^= a1;
+				g = Rotate32(g, 19);
+				g = g * 5 + 0xe6546b64;
+				g ^= a3;
+				g = Rotate32(g, 19);
+				g = g * 5 + 0xe6546b64;
+				f += a4;
+				f = Rotate32(f, 19) + 113;
+				uint iters = (len - 1) / 20;
+				do
+				{
+					uint a = Fetch32(s);
+					uint b = Fetch32(s + 4);
+					uint c = Fetch32(s + 8);
+					uint d = Fetch32(s + 12);
+					uint e = Fetch32(s + 16);
+					h += a;
+					g += b;
+					f += c;
+					h = Mur(d, h) + e;
+					g = Mur(c, g) + a;
+					f = Mur(b + e * c1, f) + d;
+					f += g;
+					g += f;
+					s += 20;
+				} while (--iters != 0);
+				g = Rotate32(g, 11) * c1;
+				g = Rotate32(g, 17) * c1;
+				f = Rotate32(f, 11) * c1;
+				f = Rotate32(f, 17) * c1;
+				h = Rotate32(h + g, 19);
+				h = h * 5 + 0xe6546b64;
+				h = Rotate32(h, 17) * c1;
+				h = Rotate32(h + f, 19);
+				h = h * 5 + 0xe6546b64;
+				h = Rotate32(h, 17) * c1;
+				return h;
+			}
+
+			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
+			{
+				if (len <= 24)
+				{
+					if (len >= 13)
+					{
+						return Hash32Len13to24(s, len, seed * c1);
+					}
+					else if (len >= 5)
+					{
+						return Hash32Len5to12(s, len, seed);
+					}
+					else
+					{
+						return Hash32Len0to4(s, len, seed);
+					}
+				}
+
+				uint h = Hash32Len13to24(s, 24, seed ^ len);
+				return Mur(Hash32(s + 24, len - 24) + seed, h);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs b/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
new file mode 100644
index 000000000..e6a1f4090
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
@@ -0,0 +1,246 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		private static class NA
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static ulong Hash128to64((ulong low, ulong high) x)
+			{
+				// Murmur-inspired hashing.
+				const ulong kMul = 0x9ddfea08eb382d69UL;
+				ulong a = (x.low ^ x.high) * kMul;
+				a ^= (a >> 47);
+				ulong b = (x.high ^ a) * kMul;
+				b ^= (b >> 47);
+				b *= kMul;
+				return b;
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe ulong ShiftMix(ulong val)
+			{
+				return val ^ (val >> 47);
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe ulong HashLen16(ulong u, ulong v)
+			{
+				return Hash128to64((u, v));
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe ulong HashLen16(ulong u, ulong v, ulong mul)
+			{
+				// Murmur-inspired hashing.
+				ulong a = (u ^ v) * mul;
+				a ^= (a >> 47);
+				ulong b = (v ^ a) * mul;
+				b ^= (b >> 47);
+				b *= mul;
+				return b;
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe ulong HashLen0to16(byte* s, uint len)
+			{
+				if (len >= 8)
+				{
+					ulong mul = k2 + len * 2;
+					ulong a = Fetch64(s) + k2;
+					ulong b = Fetch64(s + len - 8);
+					ulong c = Rotate64(b, 37) * mul + a;
+					ulong d = (Rotate64(a, 25) + b) * mul;
+					return HashLen16(c, d, mul);
+				}
+				if (len >= 4)
+				{
+					ulong mul = k2 + len * 2;
+					ulong a = Fetch32(s);
+					return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
+				}
+				if (len > 0)
+				{
+					byte a = s[0];
+					byte b = s[len >> 1];
+					byte c = s[len - 1];
+					uint y = (uint)a + ((uint)b << 8);
+					uint z = len + ((uint)c << 2);
+					return ShiftMix(y * k2 ^ z * k0) * k2;
+				}
+				return k2;
+			}
+
+			// This probably works well for 16-byte strings as well, but it may be overkill
+			// in that case.
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe ulong HashLen17to32(byte* s, uint len)
+			{
+				ulong mul = k2 + len * 2;
+				ulong a = Fetch64(s) * k1;
+				ulong b = Fetch64(s + 8);
+				ulong c = Fetch64(s + len - 8) * mul;
+				ulong d = Fetch64(s + len - 16) * k2;
+				return HashLen16(Rotate64(a + b, 43) + Rotate64(c, 30) + d,
+								 a + Rotate64(b + k2, 18) + c, mul);
+			}
+
+			// Return a 16-byte hash for 48 bytes.  Quick and dirty.
+			// Callers do best to use "random-looking" values for a and b.
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe (ulong first, ulong second) WeakHashLen32WithSeeds(
+				ulong w, ulong x, ulong y, ulong z, ulong a, ulong b)
+			{
+				a += w;
+				b = Rotate64(b + a + z, 21);
+				ulong c = a;
+				a += x;
+				a += y;
+				b += Rotate64(a, 44);
+				return (a + z, b + c);
+			}
+
+			// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			internal static unsafe (ulong first, ulong second) WeakHashLen32WithSeeds(byte* s, ulong a, ulong b)
+			{
+				return WeakHashLen32WithSeeds(Fetch64(s),
+											  Fetch64(s + 8),
+											  Fetch64(s + 16),
+											  Fetch64(s + 24),
+											  a,
+											  b);
+			}
+
+			// Return an 8-byte hash for 33 to 64 bytes.
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe ulong HashLen33to64(byte* s, uint len)
+			{
+				ulong mul = k2 + len * 2;
+				ulong a = Fetch64(s) * k2;
+				ulong b = Fetch64(s + 8);
+				ulong c = Fetch64(s + len - 8) * mul;
+				ulong d = Fetch64(s + len - 16) * k2;
+				ulong y = Rotate64(a + b, 43) + Rotate64(c, 30) + d;
+				ulong z = HashLen16(y, a + Rotate64(b + k2, 18) + c, mul);
+				ulong e = Fetch64(s + 16) * mul;
+				ulong f = Fetch64(s + 24);
+				ulong g = (y + Fetch64(s + len - 32)) * mul;
+				ulong h = (z + Fetch64(s + len - 24)) * mul;
+				return HashLen16(Rotate64(e + f, 43) + Rotate64(g, 30) + h,
+								 e + Rotate64(f + a, 18) + g, mul);
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static void swap(ref ulong left, ref ulong right)
+			{
+				var temp = left;
+				left = right;
+				right = temp;
+			}
+
+			public static unsafe ulong Hash64(byte* s, uint len)
+			{
+				const ulong seed = 81;
+				if (len <= 32)
+				{
+					if (len <= 16)
+					{
+						return HashLen0to16(s, len);
+					}
+					else
+					{
+						return HashLen17to32(s, len);
+					}
+				}
+				else if (len <= 64)
+				{
+					return HashLen33to64(s, len);
+				}
+
+				// For strings over 64 bytes we loop.  Internal state consists of
+				// 56 bytes: v, w, x, y, and z.
+				ulong x = seed;
+				ulong y = unchecked(seed * k1) + 113;
+				ulong z = ShiftMix(y * k2 + 113) * k2;
+				(ulong first, ulong second) v = (0, 0);
+				(ulong first, ulong second) w = (0, 0);
+				x = x * k2 + Fetch64(s);
+
+				// Set end so that after the loop we have 1 to 64 bytes left to process.
+				byte* end = s + ((len - 1) / 64) * 64;
+				byte* last64 = end + ((len - 1) & 63) - 63;
+				Debug.Assert(s + len - 64 == last64);
+				do
+				{
+					x = Rotate64(x + y + v.first + Fetch64(s + 8), 37) * k1;
+					y = Rotate64(y + v.second + Fetch64(s + 48), 42) * k1;
+					x ^= w.second;
+					y += v.first + Fetch64(s + 40);
+					z = Rotate64(z + w.first, 33) * k1;
+					v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
+					w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
+					swap(ref z, ref x);
+					s += 64;
+				} while (s != end);
+				ulong mul = k1 + ((z & 0xff) << 1);
+				// Make s point to the last 64 bytes of input.
+				s = last64;
+				w.first += ((len - 1) & 63);
+				v.first += w.first;
+				w.first += v.first;
+				x = Rotate64(x + y + v.first + Fetch64(s + 8), 37) * mul;
+				y = Rotate64(y + v.second + Fetch64(s + 48), 42) * mul;
+				x ^= w.second * 9;
+				y += v.first * 9 + Fetch64(s + 40);
+				z = Rotate64(z + w.first, 33) * mul;
+				v = WeakHashLen32WithSeeds(s, v.second * mul, x + w.first);
+				w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
+				swap(ref z, ref x);
+				return HashLen16(HashLen16(v.first, w.first, mul) + ShiftMix(y) * k0 + z,
+								 HashLen16(v.second, w.second, mul) + x,
+								 mul);
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64WithSeed(byte* s, uint len, ulong seed)
+				=> Hash64WithSeeds(s, len, k2, seed);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64WithSeeds(byte* s, uint len, ulong seed0, ulong seed1)
+				=> HashLen16(Hash64(s, len) - seed0, seed1);
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs b/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs
new file mode 100644
index 000000000..242c877bc
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs
@@ -0,0 +1,47 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		internal static class NT
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe uint Hash32(byte* s, uint len)
+				=> (uint)(TE.Hash64(s, len) & 0xFFFFFFFF);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
+				=> (uint)(TE.Hash64WithSeed(s, len, seed) & 0xFFFFFFFF);
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
new file mode 100644
index 000000000..6d30a1899
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
@@ -0,0 +1,277 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+using __m128i = System.Runtime.Intrinsics.Vector128<uint>;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		internal static class SA
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe __m128i Fetch128(byte* s)
+				=> Sse2.LoadVector128(s).AsUInt32(); // _mm_loadu_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Add(__m128i x, __m128i y)
+				=> Sse2.Add(x, y); // _mm_add_epi32
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Xor(__m128i x, __m128i y)
+				=> Sse2.Xor(x, y); // _mm_xor_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Or(__m128i x, __m128i y)
+				=> Sse2.Or(x, y); // _mm_or_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Mul(__m128i x, __m128i y)
+				=> Sse41.MultiplyLow(x, y); // _mm_mullo_epi32
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Mul5(__m128i x)
+				=> Add(
+					x,
+					Sse2.ShiftLeftLogical(x, 2) // _mm_slli_epi32
+				);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Rotate(__m128i x, byte c)
+				=> Or(
+					Sse2.ShiftLeftLogical(x, c),// _mm_slli_epi32
+					Sse2.ShiftRightLogical(x, (byte)(32 - c)) // _mm_srli_epi32
+				);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Rot17(__m128i x)
+				=> Rotate(x, 17);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Rot19(__m128i x)
+				=> Rotate(x, 19);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Shuffle0321(__m128i x)
+				=> Sse2.Shuffle(x, (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)); // _mm_shuffle_epi32
+
+			public static unsafe uint Hash32(byte* s, uint len)
+			{
+				const uint seed = 81;
+				if (len <= 24)
+				{
+					return len <= 12 ?
+						(len <= 4 ?
+						MK.Hash32Len0to4(s, len) :
+						MK.Hash32Len5to12(s, len)) :
+						MK.Hash32Len13to24(s, len);
+				}
+
+				if (len < 40)
+				{
+					uint a = len, b = unchecked(seed * c2), c = a + b;
+					a += Fetch32(s + len - 4);
+					b += Fetch32(s + len - 20);
+					c += Fetch32(s + len - 16);
+					uint d = a;
+					a = Rotate32(a, 21);
+					a = Mur(a, Mur(b, Mur(c, d)));
+					a += Fetch32(s + len - 12);
+					b += Fetch32(s + len - 8);
+					d += a;
+					a += d;
+					b = Mur(b, d) * c2;
+					a = Sse42.Crc32(a, b + c); // _mm_crc32_u32
+					return MK.Hash32Len13to24(s, (len + 1) / 2, a) + b;
+				}
+
+				__m128i cc1 = Vector128.Create(c1); // _mm_set1_epi32
+				__m128i cc2 = Vector128.Create(c2); // _mm_set1_epi32
+				__m128i h = Vector128.Create(seed); // _mm_set1_epi32
+				__m128i g = Vector128.Create(unchecked(c1 * seed)); // _mm_set1_epi32
+				__m128i f = g;
+				__m128i k = Vector128.Create(0xe6546b64); // _mm_set1_epi32
+				if (len < 80)
+				{
+					__m128i a = Fetch128(s);
+					__m128i b = Fetch128(s + 16);
+					__m128i c = Fetch128(s + (len - 15) / 2);
+					__m128i d = Fetch128(s + len - 32);
+					__m128i e = Fetch128(s + len - 16);
+					h = Add(h, a);
+					g = Add(g, b);
+					g = Shuffle0321(g);
+					f = Add(f, c);
+					__m128i be = Add(b, Mul(e, cc1));
+					h = Add(h, f);
+					f = Add(f, h);
+					h = Add(Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h))))), e);
+					k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+					g = Add(Xor(c, g), a);
+					f = Add(Xor(be, f), d);
+					k = Add(k, be);
+					k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+					f = Add(f, g);
+					g = Add(g, f);
+					g = Add(
+						Vector128.Create(len), // _mm_set1_epi32
+						Mul(g, cc1)
+					);
+				}
+				else
+				{
+					// len >= 80
+					// The following is loosely modelled after farmhashmk::Hash32.
+					uint iters = (len - 1) / 80;
+					len -= iters * 80;
+
+					while (iters-- != 0)
+					{
+						// <Chunk>
+						__m128i a = Fetch128(s);
+						__m128i b = Fetch128(s + 16);
+						__m128i c = Fetch128(s + 32);
+						__m128i d = Fetch128(s + 48);
+						__m128i e = Fetch128(s + 64);
+						h = Add(h, a);
+						g = Add(g, b);
+						g = Shuffle0321(g);
+						f = Add(f, c);
+						__m128i be = Add(b, Mul(e, cc1));
+						h = Add(h, f);
+						f = Add(f, h);
+						h = Add(Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h))))), e);
+						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+						g = Add(Xor(c, g), a);
+						f = Add(Xor(be, f), d);
+						k = Add(k, be);
+						k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+						f = Add(f, g);
+						g = Add(g, f);
+						f = Mul(f, cc1);
+						// </Chunk>
+						s += 80;
+					}
+
+					if (len != 0)
+					{
+						h = Add(h, Vector128.Create(len)); // _mm_set1_epi32
+						s = s + len - 80;
+						// <Chunk>
+						__m128i a = Fetch128(s);
+						__m128i b = Fetch128(s + 16);
+						__m128i c = Fetch128(s + 32);
+						__m128i d = Fetch128(s + 48);
+						__m128i e = Fetch128(s + 64);
+						h = Add(h, a);
+						g = Add(g, b);
+						g = Shuffle0321(g);
+						f = Add(f, c);
+						__m128i be = Add(b, Mul(e, cc1));
+						h = Add(h, f);
+						f = Add(f, h);
+						h = Add(Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h))))), e);
+						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+						g = Add(Xor(c, g), a);
+						f = Add(Xor(be, f), d);
+						k = Add(k, be);
+						k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+						f = Add(f, g);
+						g = Add(g, f);
+						f = Mul(f, cc1);
+						// </Chunk>
+					}
+				}
+
+				g = Shuffle0321(g);
+				k = Xor(k, g);
+				f = Mul(f, cc1);
+				k = Mul(k, cc2);
+				g = Mul(g, cc1);
+				h = Mul(h, cc2);
+				k = Add(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+				h = Add(h, f);
+				f = Add(f, h);
+				g = Add(g, k);
+				k = Add(k, g);
+				k = Xor(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+				var buf = stackalloc __m128i[4];
+				buf[0] = f;
+				buf[1] = g;
+				buf[2] = k;
+				buf[3] = h;
+				s = (byte*)(buf);
+				uint x = Fetch32(s);
+				uint y = Fetch32(s + 4);
+				uint z = Fetch32(s + 8);
+				x = Sse42.Crc32(x, Fetch32(s + 12)); // _mm_crc32_u32
+				y = Sse42.Crc32(y, Fetch32(s + 16)); // _mm_crc32_u32
+				z = Sse42.Crc32(z * c1, Fetch32(s + 20)); // _mm_crc32_u32
+				x = Sse42.Crc32(x, Fetch32(s + 24)); // _mm_crc32_u32
+				y = Sse42.Crc32(y * c1, Fetch32(s + 28)); // _mm_crc32_u32
+				uint o = y;
+				z = Sse42.Crc32(z, Fetch32(s + 32)); // _mm_crc32_u32
+				x = Sse42.Crc32(x * c1, Fetch32(s + 36)); // _mm_crc32_u32
+				y = Sse42.Crc32(y, Fetch32(s + 40)); // _mm_crc32_u32
+				z = Sse42.Crc32(z * c1, Fetch32(s + 44)); // _mm_crc32_u32
+				x = Sse42.Crc32(x, Fetch32(s + 48)); // _mm_crc32_u32
+				y = Sse42.Crc32(y * c1, Fetch32(s + 52)); // _mm_crc32_u32
+				z = Sse42.Crc32(z, Fetch32(s + 56)); // _mm_crc32_u32
+				x = Sse42.Crc32(x, Fetch32(s + 60)); // _mm_crc32_u32
+				return (o - x + y - z) * c1;
+			}
+
+			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
+			{
+				if (len <= 24)
+				{
+					if (len >= 13)
+					{
+						return MK.Hash32Len13to24(s, len, seed * c1);
+					}
+					else if (len >= 5)
+					{
+						return MK.Hash32Len5to12(s, len, seed);
+					}
+					else
+					{
+						return MK.Hash32Len0to4(s, len, seed);
+					}
+				}
+
+				uint h = MK.Hash32Len13to24(s, 24, seed ^ len);
+				return Sse42.Crc32(Hash32(s + 24, len - 24) + seed, h); // _mm_crc32_u32
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
new file mode 100644
index 000000000..dffded765
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
@@ -0,0 +1,304 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+using __m128i = System.Runtime.Intrinsics.Vector128<uint>;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		internal static class SU
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe __m128i Fetch128(byte* s)
+				=> Sse2.LoadVector128(s).AsUInt32(); // _mm_loadu_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Add(__m128i x, __m128i y)
+				=> Sse2.Add(x, y); // _mm_add_epi32
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Xor(__m128i x, __m128i y)
+				=> Sse2.Xor(x, y); // _mm_xor_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Or(__m128i x, __m128i y)
+				=> Sse2.Or(x, y); // _mm_or_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Mul(__m128i x, __m128i y)
+				=> Sse41.MultiplyLow(x, y); // _mm_mullo_epi32
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Mul5(__m128i x)
+				=> Add(
+					x,
+					Sse2.ShiftLeftLogical(x, 2) // _mm_slli_epi32
+				);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i RotateLeft(__m128i x, byte c)
+				=> Or(
+					Sse2.ShiftLeftLogical(x, c),// _mm_slli_epi32
+					Sse2.ShiftRightLogical(x, (byte)(32 - c)) // _mm_srli_epi32
+				);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Rol17(__m128i x)
+				=> RotateLeft(x, 17);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Rol19(__m128i x)
+				=> RotateLeft(x, 19);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Shuffle0321(__m128i x)
+				=> Sse2.Shuffle(x, (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)); // _mm_shuffle_epi32
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static void swap(ref __m128i left, ref __m128i right)
+			{
+				var temp = left;
+				left = right;
+				right = temp;
+			}
+
+			public static unsafe uint Hash32(byte* s, uint len)
+			{
+				const uint seed = 81;
+				if (len <= 24)
+				{
+					return len <= 12 ?
+						(len <= 4 ?
+						 MK.Hash32Len0to4(s, len) :
+						 MK.Hash32Len5to12(s, len)) :
+						MK.Hash32Len13to24(s, len);
+				}
+
+				if (len < 40)
+				{
+					uint a = len, b = unchecked(seed * c2), c = a + b;
+					a += Fetch32(s + len - 4);
+					b += Fetch32(s + len - 20);
+					c += Fetch32(s + len - 16);
+					uint d = a;
+					a = Rotate32(a, 21);
+					a = Mur(a, Mur(b, Sse42.Crc32(c, d))); // _mm_crc32_u32
+					a += Fetch32(s + len - 12);
+					b += Fetch32(s + len - 8);
+					d += a;
+					a += d;
+					b = Mur(b, d) * c2;
+					a = Sse42.Crc32(a, b + c); // _mm_crc32_u32
+					return MK.Hash32Len13to24(s, (len + 1) / 2, a) + b;
+				}
+
+				// Murk
+				// Add(k, Mul5(Rol19(Xor(Mul(Rol17(Mul(★, cc1)), cc2),(h)))))
+				// Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h)))))
+
+
+				__m128i cc1 = Vector128.Create(c1); // _mm_set1_epi32
+				__m128i cc2 = Vector128.Create(c2); // _mm_set1_epi32
+				__m128i h = Vector128.Create(seed); // _mm_set1_epi32
+				__m128i g = Vector128.Create(unchecked(c1 * seed)); // _mm_set1_epi32
+				__m128i f = g;
+				__m128i k = Vector128.Create(0xe6546b64); // _mm_set1_epi32
+				__m128i q;
+				if (len < 80)
+				{
+					__m128i a = Fetch128(s);
+					__m128i b = Fetch128(s + 16);
+					__m128i c = Fetch128(s + (len - 15) / 2);
+					__m128i d = Fetch128(s + len - 32);
+					__m128i e = Fetch128(s + len - 16);
+					h = Add(h, a);
+					g = Add(g, b);
+					q = g;
+					g = Shuffle0321(g);
+					f = Add(f, c);
+					__m128i be = Add(b, Mul(e, cc1));
+					h = Add(h, f);
+					f = Add(f, h);
+					h = Add(Add(k, Mul5(Rol19(Xor(Mul(Rol17(Mul(d, cc1)), cc2), (h))))), e);
+					k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+					g = Add(Xor(c, g), a);
+					f = Add(Xor(be, f), d);
+					k = Add(k, be);
+					k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+					f = Add(f, g);
+					g = Add(g, f);
+					g = Add(
+						 Vector128.Create(len), // _mm_set1_epi32
+						Mul(g, cc1)
+					);
+				}
+				else
+				{
+					// len >= 80
+					// The following is loosely modelled after farmhashmk::Hash32.
+					uint iters = (len - 1) / 80;
+					len -= iters * 80;
+					q = g;
+					while (iters-- != 0)
+					{
+						// <Chunk>                      
+						__m128i a = Fetch128(s);
+						__m128i b = Fetch128(s + 16);
+						__m128i c = Fetch128(s + 32);
+						__m128i d = Fetch128(s + 48);
+						__m128i e = Fetch128(s + 64);
+						h = Add(h, a);
+						g = Add(g, b);
+						g = Shuffle0321(g);
+						f = Add(f, c);
+						__m128i be = Add(b, Mul(e, cc1));
+						h = Add(h, f);
+						f = Add(f, h);
+						h = Add(h, d);
+						q = Add(q, e);
+						h = Rol17(h);
+						h = Mul(h, cc1);
+						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); //_mm_shuffle_epi8      
+						g = Add(Xor(c, g), a);
+						f = Add(Xor(be, f), d);
+						swap(ref f, ref q);
+						q = Aes.InverseMixColumns(q.AsByte()).AsUInt32(); // _mm_aesimc_si128                
+						k = Add(k, be);
+						k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32());
+						f = Add(f, g);
+						g = Add(g, f);
+						f = Mul(f, cc1);
+						// </Chunk>
+						s += 80;
+					}
+
+					if (len != 0)
+					{
+						h = Add(h, Vector128.Create(len)); // _mm_set1_epi32
+						s = s + len - 80;
+						// <Chunk>                      
+						__m128i a = Fetch128(s);
+						__m128i b = Fetch128(s + 16);
+						__m128i c = Fetch128(s + 32);
+						__m128i d = Fetch128(s + 48);
+						__m128i e = Fetch128(s + 64);
+						h = Add(h, a);
+						g = Add(g, b);
+						g = Shuffle0321(g);
+						f = Add(f, c);
+						__m128i be = Add(b, Mul(e, cc1));
+						h = Add(h, f);
+						f = Add(f, h);
+						h = Add(h, d);
+						q = Add(q, e);
+						h = Rol17(h);
+						h = Mul(h, cc1);
+						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); //_mm_shuffle_epi8      
+						g = Add(Xor(c, g), a);
+						f = Add(Xor(be, f), d);
+						swap(ref f, ref q);
+						q = Aes.InverseMixColumns(q.AsByte()).AsUInt32(); // _mm_aesimc_si128                
+						k = Add(k, be);
+						k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32());
+						f = Add(f, g);
+						g = Add(g, f);
+						f = Mul(f, cc1);
+						// </Chunk>
+					}
+				}
+
+				g = Shuffle0321(g);
+				k = Xor(k, g);
+				k = Xor(k, q);
+				h = Xor(h, q);
+				f = Mul(f, cc1);
+				k = Mul(k, cc2);
+				g = Mul(g, cc1);
+				h = Mul(h, cc2);
+				k = Add(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+				h = Add(h, f);
+				f = Add(f, h);
+				g = Add(g, k);
+				k = Add(k, g);
+				k = Xor(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32()); // _mm_shuffle_epi8
+				var buf = stackalloc __m128i[4];
+				buf[0] = f;
+				buf[1] = g;
+				buf[2] = k;
+				buf[3] = h;
+				s = (byte*)buf;
+				uint x = Fetch32(s);
+				uint y = Fetch32(s + 4);
+				uint z = Fetch32(s + 8);
+				x = Sse42.Crc32(x, Fetch32(s + 12)); // _mm_crc32_u32
+				y = Sse42.Crc32(y, Fetch32(s + 16)); // _mm_crc32_u32
+				z = Sse42.Crc32(z * c1, Fetch32(s + 20)); // _mm_crc32_u32
+				x = Sse42.Crc32(x, Fetch32(s + 24)); // _mm_crc32_u32
+				y = Sse42.Crc32(y * c1, Fetch32(s + 28)); // _mm_crc32_u32
+				uint o = y;
+				z = Sse42.Crc32(z, Fetch32(s + 32)); // _mm_crc32_u32
+				x = Sse42.Crc32(x * c1, Fetch32(s + 36)); // _mm_crc32_u32
+				y = Sse42.Crc32(y, Fetch32(s + 40)); // _mm_crc32_u32
+				z = Sse42.Crc32(z * c1, Fetch32(s + 44)); // _mm_crc32_u32
+				x = Sse42.Crc32(x, Fetch32(s + 48)); // _mm_crc32_u32
+				y = Sse42.Crc32(y * c1, Fetch32(s + 52)); // _mm_crc32_u32
+				z = Sse42.Crc32(z, Fetch32(s + 56)); // _mm_crc32_u32
+				x = Sse42.Crc32(x, Fetch32(s + 60)); // _mm_crc32_u32
+				return (o - x + y - z) * c1;
+			}
+
+			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
+			{
+				if (len <= 24)
+				{
+					if (len >= 13)
+					{
+						return MK.Hash32Len13to24(s, len, seed * c1);
+					}
+					else if (len >= 5)
+					{
+						return MK.Hash32Len5to12(s, len, seed);
+					}
+					else
+					{
+						return MK.Hash32Len0to4(s, len, seed);
+					}
+				}
+
+				uint h = MK.Hash32Len13to24(s, 24, seed ^ len);
+				return Sse42.Crc32(Hash32(s + 24, len - 24) + seed, h); // _mm_crc32_u32
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs b/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs
new file mode 100644
index 000000000..b2d11879a
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs
@@ -0,0 +1,264 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+using __m128i = System.Runtime.Intrinsics.Vector128<ulong>;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		private static class TE
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe __m128i Fetch128(byte* s)
+			=> Sse2.LoadVector128(s).AsUInt64(); // _mm_loadu_si128
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Add(__m128i x, __m128i y)
+				=> Sse2.Add(x, y); // _mm_add_epi64
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Xor(__m128i x, __m128i y)
+				=> Sse2.Xor(x, y); // _mm_xor_si128
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Mul(__m128i x, __m128i y)
+				=> Sse41.MultiplyLow(x.AsUInt32(), y.AsUInt32()).AsUInt64(); // _mm_mullo_epi32
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static __m128i Shuf(__m128i x, __m128i y)
+				=> Ssse3.Shuffle(x.AsByte(), y.AsByte()).AsUInt64(); // _mm_shuffle_epi8
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static void swap(ref __m128i left, ref __m128i right)
+			{
+				var temp = left;
+				left = right;
+				right = temp;
+			}
+
+			// Requires n >= 256.  Requires SSE4.1. Should be slightly faster if the
+			// compiler uses AVX instructions (e.g., use the -mavx flag with GCC).
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe ulong Hash64Long(byte* s, uint n, ulong seed0, ulong seed1)
+			{
+				__m128i kShuf =
+					Vector128.Create(4, 11, 10, 5, 8, 15, 6, 9, 12, 2, 14, 13, 0, 7, 3, 1).AsUInt64(); // _mm_set_epi8
+				__m128i kMult =
+					Vector128.Create(0xbd, 0xd6, 0x33, 0x39, 0x45, 0x54, 0xfa, 0x03,
+								 0x34, 0x3e, 0x33, 0xed, 0xcc, 0x9e, 0x2d, 0x51).AsUInt64(); // _mm_set_epi8
+				ulong seed2 = (seed0 + 113) * (seed1 + 9);
+				ulong seed3 = (Rotate64(seed0, 23) + 27) * (Rotate64(seed1, 30) + 111);
+				__m128i d0 = Sse2.X64.ConvertScalarToVector128UInt64(seed0); // _mm_cvtsi64_si128
+				__m128i d1 = Sse2.X64.ConvertScalarToVector128UInt64(seed1); // _mm_cvtsi64_si128
+				__m128i d2 = Shuf(kShuf, d0);
+				__m128i d3 = Shuf(kShuf, d1);
+				__m128i d4 = Xor(d0, d1);
+				__m128i d5 = Xor(d1, d2);
+				__m128i d6 = Xor(d2, d4);
+				__m128i d7 = Vector128.Create(seed2 >> 32); // _mm_set1_epi32
+				__m128i d8 = Mul(kMult, d2);
+				__m128i d9 = Vector128.Create(seed3 >> 32); // _mm_set1_epi32
+				__m128i d10 = Vector128.Create(seed3); // _mm_set1_epi32
+				__m128i d11 = Add(d2, Vector128.Create(seed2)); // _mm_set1_epi32
+				// size_t == ulong here because this code should be run under X64 process.
+				byte* end = s + (n & ~(/* size_t */ ulong)(255));
+				do
+				{
+					__m128i z;
+					z = Fetch128(s);
+					d0 = Add(d0, z);
+					d1 = Shuf(kShuf, d1);
+					d2 = Xor(d2, d0);
+					d4 = Xor(d4, z);
+					d4 = Xor(d4, d1);
+					swap(ref d0, ref d6);
+					z = Fetch128(s + 16);
+					d5 = Add(d5, z);
+					d6 = Shuf(kShuf, d6);
+					d8 = Shuf(kShuf, d8);
+					d7 = Xor(d7, d5);
+					d0 = Xor(d0, z);
+					d0 = Xor(d0, d6);
+					swap(ref d5, ref d11);
+					z = Fetch128(s + 32);
+					d1 = Add(d1, z);
+					d2 = Shuf(kShuf, d2);
+					d4 = Shuf(kShuf, d4);
+					d5 = Xor(d5, z);
+					d5 = Xor(d5, d2);
+					swap(ref d10, ref d4);
+					z = Fetch128(s + 48);
+					d6 = Add(d6, z);
+					d7 = Shuf(kShuf, d7);
+					d0 = Shuf(kShuf, d0);
+					d8 = Xor(d8, d6);
+					d1 = Xor(d1, z);
+					d1 = Add(d1, d7);
+					z = Fetch128(s + 64);
+					d2 = Add(d2, z);
+					d5 = Shuf(kShuf, d5);
+					d4 = Add(d4, d2);
+					d6 = Xor(d6, z);
+					d6 = Xor(d6, d11);
+					swap(ref d8, ref d2);
+					z = Fetch128(s + 80);
+					d7 = Xor(d7, z);
+					d8 = Shuf(kShuf, d8);
+					d1 = Shuf(kShuf, d1);
+					d0 = Add(d0, d7);
+					d2 = Add(d2, z);
+					d2 = Add(d2, d8);
+					swap(ref d1, ref d7);
+					z = Fetch128(s + 96);
+					d4 = Shuf(kShuf, d4);
+					d6 = Shuf(kShuf, d6);
+					d8 = Mul(kMult, d8);
+					d5 = Xor(d5, d11);
+					d7 = Xor(d7, z);
+					d7 = Add(d7, d4);
+					swap(ref d6, ref d0);
+					z = Fetch128(s + 112);
+					d8 = Add(d8, z);
+					d0 = Shuf(kShuf, d0);
+					d2 = Shuf(kShuf, d2);
+					d1 = Xor(d1, d8);
+					d10 = Xor(d10, z);
+					d10 = Xor(d10, d0);
+					swap(ref d11, ref d5);
+					z = Fetch128(s + 128);
+					d4 = Add(d4, z);
+					d5 = Shuf(kShuf, d5);
+					d7 = Shuf(kShuf, d7);
+					d6 = Add(d6, d4);
+					d8 = Xor(d8, z);
+					d8 = Xor(d8, d5);
+					swap(ref d4, ref d10);
+					z = Fetch128(s + 144);
+					d0 = Add(d0, z);
+					d1 = Shuf(kShuf, d1);
+					d2 = Add(d2, d0);
+					d4 = Xor(d4, z);
+					d4 = Xor(d4, d1);
+					z = Fetch128(s + 160);
+					d5 = Add(d5, z);
+					d6 = Shuf(kShuf, d6);
+					d8 = Shuf(kShuf, d8);
+					d7 = Xor(d7, d5);
+					d0 = Xor(d0, z);
+					d0 = Xor(d0, d6);
+					swap(ref d2, ref d8);
+					z = Fetch128(s + 176);
+					d1 = Add(d1, z);
+					d2 = Shuf(kShuf, d2);
+					d4 = Shuf(kShuf, d4);
+					d5 = Mul(kMult, d5);
+					d5 = Xor(d5, z);
+					d5 = Xor(d5, d2);
+					swap(ref d7, ref d1);
+					z = Fetch128(s + 192);
+					d6 = Add(d6, z);
+					d7 = Shuf(kShuf, d7);
+					d0 = Shuf(kShuf, d0);
+					d8 = Add(d8, d6);
+					d1 = Xor(d1, z);
+					d1 = Xor(d1, d7);
+					swap(ref d0, ref d6);
+					z = Fetch128(s + 208);
+					d2 = Add(d2, z);
+					d5 = Shuf(kShuf, d5);
+					d4 = Xor(d4, d2);
+					d6 = Xor(d6, z);
+					d6 = Xor(d6, d9);
+					swap(ref d5, ref d11);
+					z = Fetch128(s + 224);
+					d7 = Add(d7, z);
+					d8 = Shuf(kShuf, d8);
+					d1 = Shuf(kShuf, d1);
+					d0 = Xor(d0, d7);
+					d2 = Xor(d2, z);
+					d2 = Xor(d2, d8);
+					swap(ref d10, ref d4);
+					z = Fetch128(s + 240);
+					d3 = Add(d3, z);
+					d4 = Shuf(kShuf, d4);
+					d6 = Shuf(kShuf, d6);
+					d7 = Mul(kMult, d7);
+					d5 = Add(d5, d3);
+					d7 = Xor(d7, z);
+					d7 = Xor(d7, d4);
+					swap(ref d3, ref d9);
+					s += 256;
+				} while (s != end);
+				d6 = Add(Mul(kMult, d6), Sse2.X64.ConvertScalarToVector128UInt64(n)); // _mm_cvtsi64_si128
+				if (n % 256 != 0)
+				{
+					d7 = Add(Sse2.Shuffle(d8.AsUInt32(), (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)).AsUInt64(), d7); // _mm_shuffle_epi32
+					d8 = Add(Mul(kMult, d8), Sse2.X64.ConvertScalarToVector128UInt64(XO.Hash64(s, n % 256))); // _mm_cvtsi64_si128
+				}
+				var t = stackalloc __m128i[8];
+				d0 = Mul(kMult, Shuf(kShuf, Mul(kMult, d0)));
+				d3 = Mul(kMult, Shuf(kShuf, Mul(kMult, d3)));
+				d9 = Mul(kMult, Shuf(kShuf, Mul(kMult, d9)));
+				d1 = Mul(kMult, Shuf(kShuf, Mul(kMult, d1)));
+				d0 = Add(d11, d0);
+				d3 = Xor(d7, d3);
+				d9 = Add(d8, d9);
+				d1 = Add(d10, d1);
+				d4 = Add(d3, d4);
+				d5 = Add(d9, d5);
+				d6 = Xor(d1, d6);
+				d2 = Add(d0, d2);
+				t[0] = d0;
+				t[1] = d3;
+				t[2] = d9;
+				t[3] = d1;
+				t[4] = d4;
+				t[5] = d5;
+				t[6] = d6;
+				t[7] = d2;
+				return XO.Hash64((byte*)t, /* sizeof(t) */ 8);
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64(byte* s, uint len)
+				=> len >= 512 ?
+					Hash64Long(s, len, k2, k1) :
+					XO.Hash64(s, len);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64WithSeed(byte* s, uint len, uint seed)
+				=> len >= 512 ?
+					Hash64Long(s, len, k1, seed) :
+					XO.Hash64WithSeed(s, len, seed);
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs b/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
new file mode 100644
index 000000000..2b2ccb248
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
@@ -0,0 +1,163 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		private static class UO
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static void swap(ref ulong left, ref ulong right)
+			{
+				var temp = left;
+				left = right;
+				right = temp;
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe ulong H(ulong x, ulong y, ulong mul, int r)
+			{
+				ulong a = (x ^ y) * mul;
+				a ^= (a >> 47);
+				ulong b = (y ^ a) * mul;
+				return Rotate64(b, r) * mul;
+			}
+
+			private static unsafe ulong Hash64WithSeeds(byte* s, uint len,
+							 ulong seed0, ulong seed1)
+			{
+				if (len <= 64)
+				{
+					return NA.Hash64WithSeeds(s, len, seed0, seed1);
+				}
+
+				// For strings over 64 bytes we loop.  Internal state consists of
+				// 64 bytes: u, v, w, x, y, and z.
+				ulong x = seed0;
+				ulong y = seed1 * k2 + 113;
+				ulong z = NA.ShiftMix(y * k2) * k2;
+				(ulong first, ulong second) v = (seed0, seed1);
+				(ulong first, ulong second) w = (0, 0);
+				ulong u = x - z;
+				x *= k2;
+				ulong mul = k2 + (u & 0x82);
+
+				// Set end so that after the loop we have 1 to 64 bytes left to process.
+				byte* end = s + ((len - 1) / 64) * 64;
+				byte* last64 = end + ((len - 1) & 63) - 63;
+				Debug.Assert(s + len - 64 == last64);
+				do
+				{
+					ulong a0 = Fetch64(s);
+					ulong a1 = Fetch64(s + 8);
+					ulong a2 = Fetch64(s + 16);
+					ulong a3 = Fetch64(s + 24);
+					ulong a4 = Fetch64(s + 32);
+					ulong a5 = Fetch64(s + 40);
+					ulong a6 = Fetch64(s + 48);
+					ulong a7 = Fetch64(s + 56);
+					x += a0 + a1;
+					y += a2;
+					z += a3;
+					v.first += a4;
+					v.second += a5 + a1;
+					w.first += a6;
+					w.second += a7;
+
+					x = Rotate64(x, 26);
+					x *= 9;
+					y = Rotate64(y, 29);
+					z *= mul;
+					v.first = Rotate64(v.first, 33);
+					v.second = Rotate64(v.second, 30);
+					w.first ^= x;
+					w.first *= 9;
+					z = Rotate64(z, 32);
+					z += w.second;
+					w.second += z;
+					z *= 9;
+					swap(ref u, ref y);
+
+					z += a0 + a6;
+					v.first += a2;
+					v.second += a3;
+					w.first += a4;
+					w.second += a5 + a6;
+					x += a1;
+					y += a7;
+
+					y += v.first;
+					v.first += x - y;
+					v.second += w.first;
+					w.first += v.second;
+					w.second += x - y;
+					x += w.second;
+					w.second = Rotate64(w.second, 34);
+					swap(ref u, ref z);
+					s += 64;
+				} while (s != end);
+				// Make s point to the last 64 bytes of input.
+				s = last64;
+				u *= 9;
+				v.second = Rotate64(v.second, 28);
+				v.first = Rotate64(v.first, 20);
+				w.first += ((len - 1) & 63);
+				u += y;
+				y += u;
+				x = Rotate64(y - x + v.first + Fetch64(s + 8), 37) * mul;
+				y = Rotate64(y ^ v.second ^ Fetch64(s + 48), 42) * mul;
+				x ^= w.second * 9;
+				y += v.first + Fetch64(s + 40);
+				z = Rotate64(z + w.first, 33) * mul;
+				v = NA.WeakHashLen32WithSeeds(s, v.second * mul, x + w.first);
+				w = NA.WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
+				return H(NA.HashLen16(v.first + x, w.first ^ y, mul) + z - u,
+						 H(v.second + y, w.second + z, k2, 30) ^ x,
+						 k2,
+						 31);
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64WithSeed(byte* s, uint len, ulong seed) 
+				=> len <= 64 ?
+					NA.Hash64WithSeed(s, len, seed) :
+					Hash64WithSeeds(s, len, 0, seed);
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64(byte* s, uint len)
+				=> len <= 64 ?
+					NA.Hash64(s, len) :
+					Hash64WithSeeds(s, len, 81, 0);
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.XO.cs b/src/MsgPack.Abstraction/Internal/FarmHash.XO.cs
new file mode 100644
index 000000000..4b29fa36b
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.XO.cs
@@ -0,0 +1,112 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		private static class XO
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe ulong H32(byte* s, uint len, ulong mul,
+						   ulong seed0 = 0, ulong seed1 = 0)
+			{
+				ulong a = Fetch64(s) * k1;
+				ulong b = Fetch64(s + 8);
+				ulong c = Fetch64(s + len - 8) * mul;
+				ulong d = Fetch64(s + len - 16) * k2;
+				ulong u = Rotate64(a + b, 43) + Rotate64(c, 30) + d + seed0;
+				ulong v = a + Rotate64(b + k2, 18) + c + seed1;
+				a = NA.ShiftMix((u ^ v) * mul);
+				b = NA.ShiftMix((v ^ a) * mul);
+				return b;
+			}
+
+			// Return an 8-byte hash for 33 to 64 bytes.
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe ulong HashLen33to64(byte* s, uint len)
+			{
+				ulong mul0 = k2 - 30;
+				ulong mul1 = k2 - 30 + 2 * len;
+				ulong h0 = H32(s, 32, mul0);
+				ulong h1 = H32(s + len - 32, 32, mul1);
+				return ((h1 * mul1) + h0) * mul1;
+			}
+
+			// Return an 8-byte hash for 65 to 96 bytes.
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			private static unsafe ulong HashLen65to96(byte* s, uint len)
+			{
+				ulong mul0 = k2 - 114;
+				ulong mul1 = k2 - 114 + 2 * len;
+				ulong h0 = H32(s, 32, mul0);
+				ulong h1 = H32(s + 32, 32, mul1);
+				ulong h2 = H32(s + len - 32, 32, mul1, h0, h1);
+				return (h2 * 9 + (h0 >> 17) + (h1 >> 21)) * mul1;
+			}
+
+			internal static unsafe ulong Hash64(byte* s, uint len)
+			{
+				if (len <= 32)
+				{
+					if (len <= 16)
+					{
+						return NA.HashLen0to16(s, len);
+					}
+					else
+					{
+						return NA.HashLen17to32(s, len);
+					}
+				}
+				else if (len <= 64)
+				{
+					return HashLen33to64(s, len);
+				}
+				else if (len <= 96)
+				{
+					return HashLen65to96(s, len);
+				}
+				else if (len <= 256)
+				{
+					return NA.Hash64(s, len);
+				}
+				else
+				{
+					return UO.Hash64(s, len);
+				}
+			}
+
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			public static unsafe ulong Hash64WithSeed(byte* s, uint len, ulong seed)
+				=> UO.Hash64WithSeed(s, len, seed);
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.cs b/src/MsgPack.Abstraction/Internal/FarmHash.cs
new file mode 100644
index 000000000..c64ddf511
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.cs
@@ -0,0 +1,164 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// This file is ported from Google's FarmHash (https://github.com/google/farmhash/)
+// Original copyright notice is following:
+
+// Copyright (c) 2014 Google, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// FarmHash, by Geoff Pike
+
+using System;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+
+using RandomNumberGenerator = System.Security.Cryptography.RandomNumberGenerator;
+
+namespace MsgPack.Internal
+{
+	internal static partial class FarmHash
+	{
+		private const uint c1 = 0xcc9e2d51;
+		private const uint c2 = 0x1b873593;
+		private const ulong k0 = 0xc3a5c85c97cb3127UL;
+		private const ulong k1 = 0xb492b66fbe98f273UL;
+		private const ulong k2 = 0x9ae16a3b2f90404fUL;
+
+		/// <summary>
+		///		Hash function for a byte array. 
+		///		May change from time to time, may differ on different platforms.
+		/// </summary>
+		/// <param name="bytes">Target byte span.</param>
+		/// <returns>Non-cryptgraphic, temporal hash value suitable as hash code.</returns>
+		public static unsafe int Hash32(ReadOnlySpan<byte> bytes)
+		{
+			unchecked
+			{
+				fixed (byte* s = bytes)
+				{
+					if (Sse41.IsSupported && RuntimeInformation.ProcessArchitecture == Architecture.X64)
+					{
+						return (int)NT.Hash32(s, (uint)bytes.Length);
+					}
+
+					if (Sse42.IsSupported && Aes.IsSupported)
+					{
+						return (int)SU.Hash32(s, (uint)bytes.Length);
+					}
+
+					if (Sse42.IsSupported)
+					{
+						return (int)SA.Hash32(s, (uint)bytes.Length);
+					}
+
+					return (int)MK.Hash32(s, (uint)bytes.Length);
+				}
+			}
+		}
+
+		/// <summary>
+		///		Hash function for a byte array. 
+		///		May change from time to time, may differ on different platforms.
+		/// </summary>
+		/// <param name="bytes">Target byte span.</param>
+		/// <returns>Non-cryptgraphic, temporal hash value suitable as hash code.</returns>
+		public static unsafe int Hash32WithSeed(ReadOnlySpan<byte> bytes, uint seed)
+		{
+			unchecked
+			{
+				fixed (byte* s = bytes)
+				{
+					if (Sse41.IsSupported && RuntimeInformation.ProcessArchitecture == Architecture.X64)
+					{
+						return (int)NT.Hash32WithSeed(s, (uint)bytes.Length, seed);
+					}
+
+					if (Sse42.IsSupported && Aes.IsSupported)
+					{
+						return (int)SU.Hash32WithSeed(s, (uint)bytes.Length, seed);
+					}
+
+					if (Sse42.IsSupported)
+					{
+						return (int)SA.Hash32WithSeed(s, (uint)bytes.Length, seed);
+					}
+
+					return (int)MK.Hash32WithSeed(s, (uint)bytes.Length, seed);
+				}
+			}
+		}
+
+		public static readonly uint DefaultSeed = InitializeRandomSeed();
+
+		private static uint InitializeRandomSeed()
+		{
+			using var rng = RandomNumberGenerator.Create();
+			Span<byte> bytes = stackalloc byte[sizeof(uint)];
+			rng.GetBytes(bytes);
+			return BinaryPrimitives.ReadUInt32LittleEndian(bytes);
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static unsafe uint Fetch32(byte* p)
+			=> *(uint*)p;
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static unsafe ulong Fetch64(byte* p)
+			=> *(ulong*)p;
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static uint Rotate32(uint val, int shift)
+			// Avoid shifting by 32: doing so yields an undefined result.
+			=> shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static ulong Rotate64(ulong val, int shift)
+			// Avoid shifting by 64: doing so yields an undefined result.
+			=> shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static uint fmix(uint h)
+		{
+			h ^= h >> 16;
+			h *= 0x85ebca6b;
+			h ^= h >> 13;
+			h *= 0xc2b2ae35;
+			h ^= h >> 16;
+			return h;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static uint Mur(uint a, uint h)
+		{
+			// Helper from Murmur3 for combining two 32-bit values.
+			a *= c1;
+			a = Rotate32(a, 17);
+			a *= c2;
+			h ^= a;
+			h = Rotate32(h, 19);
+			return h * 5 + 0xe6546b64;
+		}
+	}
+}
+

From 48a18dcd5a8966fdc9e9050f26432a07a8ba34c5 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 15 Jul 2020 20:15:39 +0900
Subject: [PATCH 42/82] Remove Hash32 without seed

---
 .../Internal/FarmHash.NT.cs                   |  4 ---
 .../Internal/FarmHash.TE.cs                   |  6 ----
 src/MsgPack.Abstraction/Internal/FarmHash.cs  | 32 -------------------
 3 files changed, 42 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs b/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs
index 242c877bc..36d671bd5 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.NT.cs
@@ -35,10 +35,6 @@ internal partial class FarmHash
 	{
 		internal static class NT
 		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			public static unsafe uint Hash32(byte* s, uint len)
-				=> (uint)(TE.Hash64(s, len) & 0xFFFFFFFF);
-
 			[MethodImpl(MethodImplOptions.AggressiveInlining)]
 			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
 				=> (uint)(TE.Hash64WithSeed(s, len, seed) & 0xFFFFFFFF);
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs b/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs
index b2d11879a..942fbf305 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.TE.cs
@@ -248,12 +248,6 @@ private static unsafe ulong Hash64Long(byte* s, uint n, ulong seed0, ulong seed1
 				return XO.Hash64((byte*)t, /* sizeof(t) */ 8);
 			}
 
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			public static unsafe ulong Hash64(byte* s, uint len)
-				=> len >= 512 ?
-					Hash64Long(s, len, k2, k1) :
-					XO.Hash64(s, len);
-
 			[MethodImpl(MethodImplOptions.AggressiveInlining)]
 			public static unsafe ulong Hash64WithSeed(byte* s, uint len, uint seed)
 				=> len >= 512 ?
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.cs b/src/MsgPack.Abstraction/Internal/FarmHash.cs
index c64ddf511..fdbf85908 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.cs
@@ -45,38 +45,6 @@ internal static partial class FarmHash
 		private const ulong k1 = 0xb492b66fbe98f273UL;
 		private const ulong k2 = 0x9ae16a3b2f90404fUL;
 
-		/// <summary>
-		///		Hash function for a byte array. 
-		///		May change from time to time, may differ on different platforms.
-		/// </summary>
-		/// <param name="bytes">Target byte span.</param>
-		/// <returns>Non-cryptgraphic, temporal hash value suitable as hash code.</returns>
-		public static unsafe int Hash32(ReadOnlySpan<byte> bytes)
-		{
-			unchecked
-			{
-				fixed (byte* s = bytes)
-				{
-					if (Sse41.IsSupported && RuntimeInformation.ProcessArchitecture == Architecture.X64)
-					{
-						return (int)NT.Hash32(s, (uint)bytes.Length);
-					}
-
-					if (Sse42.IsSupported && Aes.IsSupported)
-					{
-						return (int)SU.Hash32(s, (uint)bytes.Length);
-					}
-
-					if (Sse42.IsSupported)
-					{
-						return (int)SA.Hash32(s, (uint)bytes.Length);
-					}
-
-					return (int)MK.Hash32(s, (uint)bytes.Length);
-				}
-			}
-		}
-
 		/// <summary>
 		///		Hash function for a byte array. 
 		///		May change from time to time, may differ on different platforms.

From cab8af1827522dde9640ef184f660c05332a5cd3 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 15 Jul 2020 20:16:01 +0900
Subject: [PATCH 43/82] Remove duplicated code

---
 .../Internal/FarmHash.SA.cs                   | 23 +----------
 .../Internal/FarmHash.SU.cs                   | 23 +----------
 src/MsgPack.Abstraction/Internal/FarmHash.cs  | 38 +++++++++++++++----
 3 files changed, 35 insertions(+), 49 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
index 6d30a1899..b7f8ab57c 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
@@ -251,27 +251,8 @@ public static unsafe uint Hash32(byte* s, uint len)
 				return (o - x + y - z) * c1;
 			}
 
-			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
-			{
-				if (len <= 24)
-				{
-					if (len >= 13)
-					{
-						return MK.Hash32Len13to24(s, len, seed * c1);
-					}
-					else if (len >= 5)
-					{
-						return MK.Hash32Len5to12(s, len, seed);
-					}
-					else
-					{
-						return MK.Hash32Len0to4(s, len, seed);
-					}
-				}
-
-				uint h = MK.Hash32Len13to24(s, 24, seed ^ len);
-				return Sse42.Crc32(Hash32(s + 24, len - 24) + seed, h); // _mm_crc32_u32
-			}
+			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed, uint h)
+				=> Sse42.Crc32(Hash32(s + 24, len - 24) + seed, h); // _mm_crc32_u32
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
index dffded765..8b1e173d7 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
@@ -278,27 +278,8 @@ public static unsafe uint Hash32(byte* s, uint len)
 				return (o - x + y - z) * c1;
 			}
 
-			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed)
-			{
-				if (len <= 24)
-				{
-					if (len >= 13)
-					{
-						return MK.Hash32Len13to24(s, len, seed * c1);
-					}
-					else if (len >= 5)
-					{
-						return MK.Hash32Len5to12(s, len, seed);
-					}
-					else
-					{
-						return MK.Hash32Len0to4(s, len, seed);
-					}
-				}
-
-				uint h = MK.Hash32Len13to24(s, 24, seed ^ len);
-				return Sse42.Crc32(Hash32(s + 24, len - 24) + seed, h); // _mm_crc32_u32
-			}
+			public static unsafe uint Hash32WithSeed(byte* s, uint len, uint seed, uint h)
+				=> Sse42.Crc32(Hash32(s + 24, len - 24) + seed, h); // _mm_crc32_u32
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.cs b/src/MsgPack.Abstraction/Internal/FarmHash.cs
index fdbf85908..29847e39f 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.cs
@@ -53,23 +53,47 @@ internal static partial class FarmHash
 		/// <returns>Non-cryptgraphic, temporal hash value suitable as hash code.</returns>
 		public static unsafe int Hash32WithSeed(ReadOnlySpan<byte> bytes, uint seed)
 		{
+			var len = (uint)bytes.Length;
 			unchecked
 			{
 				fixed (byte* s = bytes)
 				{
 					if (Sse41.IsSupported && RuntimeInformation.ProcessArchitecture == Architecture.X64)
 					{
-						return (int)NT.Hash32WithSeed(s, (uint)bytes.Length, seed);
-					}
-
-					if (Sse42.IsSupported && Aes.IsSupported)
-					{
-						return (int)SU.Hash32WithSeed(s, (uint)bytes.Length, seed);
+						return (int)NT.Hash32WithSeed(s, len, seed);
 					}
 
 					if (Sse42.IsSupported)
 					{
-						return (int)SA.Hash32WithSeed(s, (uint)bytes.Length, seed);
+						// farmhashsa::Hash32WithSeed and farmshahsu::Hash32WithSeed is same for less than or equal to 24bytes,
+						// so inline here to reduce code size.
+						if (len <= 24)
+						{
+							if (len >= 13)
+							{
+								return (int)MK.Hash32Len13to24(s, len, seed * c1);
+							}
+							else if (len >= 5)
+							{
+								return (int)MK.Hash32Len5to12(s, len, seed);
+							}
+							else
+							{
+								return (int)MK.Hash32Len0to4(s, len, seed);
+							}
+						}
+
+						// Calculation of h is also common.
+						uint h = MK.Hash32Len13to24(s, 24, seed ^ len);
+
+						if (Aes.IsSupported)
+						{
+							return (int)SU.Hash32WithSeed(s, (uint)bytes.Length, seed, h);
+						}
+						else
+						{
+							return (int)SA.Hash32WithSeed(s, (uint)bytes.Length, seed, h);
+						}
 					}
 
 					return (int)MK.Hash32WithSeed(s, (uint)bytes.Length, seed);

From aaf5416431925e1acef577b76af3bef785132280 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 15 Jul 2020 20:32:01 +0900
Subject: [PATCH 44/82] Aggregate duplicate code depends on SSE directly or
 indirectly

---
 .../Internal/FarmHash.IntelCommon.cs          | 78 +++++++++++++++++++
 .../Internal/FarmHash.NA.cs                   |  8 --
 .../Internal/FarmHash.SA.cs                   | 53 +------------
 .../Internal/FarmHash.SU.cs                   | 46 -----------
 .../Internal/FarmHash.UO.cs                   |  8 --
 src/MsgPack.Abstraction/Internal/FarmHash.cs  |  9 ---
 6 files changed, 81 insertions(+), 121 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs

diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs b/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs
new file mode 100644
index 000000000..342835e76
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs
@@ -0,0 +1,78 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace MsgPack.Internal
+{
+	internal partial class FarmHash
+	{
+		// Common methods for Intel compatible CPU intrinsics and corresponds 64bit methods.
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static unsafe ulong Fetch64(byte* p)
+			=> *(ulong*)p;
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static unsafe Vector128<uint> Fetch128(byte* s)
+			=> Sse2.LoadVector128(s).AsUInt32(); // _mm_loadu_si128
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static ulong Rotate64(ulong val, int shift)
+			// Avoid shifting by 64: doing so yields an undefined result.
+			=> shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Add(Vector128<uint> x, Vector128<uint> y)
+			=> Sse2.Add(x, y); // _mm_add_epi32
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Xor(Vector128<uint> x, Vector128<uint> y)
+			=> Sse2.Xor(x, y); // _mm_xor_si128
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Or(Vector128<uint> x, Vector128<uint> y)
+			=> Sse2.Or(x, y); // _mm_or_si128
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Mul(Vector128<uint> x, Vector128<uint> y)
+			=> Sse41.MultiplyLow(x, y); // _mm_mullo_epi32
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Mul5(Vector128<uint> x)
+			=> Add(
+				x,
+				Sse2.ShiftLeftLogical(x, 2) // _mm_slli_epi32
+			);
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> RotateLeft(Vector128<uint> x, byte c)
+			=> Or(
+				Sse2.ShiftLeftLogical(x, c),// _mm_slli_epi32
+				Sse2.ShiftRightLogical(x, (byte)(32 - c)) // _mm_srli_epi32
+			);
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Rol17(Vector128<uint> x)
+			=> RotateLeft(x, 17);
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Rol19(Vector128<uint> x)
+			=> RotateLeft(x, 19);
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static Vector128<uint> Shuffle0321(Vector128<uint> x)
+			=> Sse2.Shuffle(x, (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)); // _mm_shuffle_epi32
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private static void swap(ref ulong left, ref ulong right)
+		{
+			var temp = left;
+			left = right;
+			right = temp;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs b/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
index e6a1f4090..817e70208 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
@@ -163,14 +163,6 @@ private static unsafe ulong HashLen33to64(byte* s, uint len)
 								 e + Rotate64(f + a, 18) + g, mul);
 			}
 
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static void swap(ref ulong left, ref ulong right)
-			{
-				var temp = left;
-				left = right;
-				right = temp;
-			}
-
 			public static unsafe ulong Hash64(byte* s, uint len)
 			{
 				const ulong seed = 81;
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
index b7f8ab57c..0bfb2ad24 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SA.cs
@@ -27,7 +27,6 @@
 //
 // FarmHash, by Geoff Pike
 
-using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
@@ -39,52 +38,6 @@ internal partial class FarmHash
 	{
 		internal static class SA
 		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static unsafe __m128i Fetch128(byte* s)
-				=> Sse2.LoadVector128(s).AsUInt32(); // _mm_loadu_si128
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Add(__m128i x, __m128i y)
-				=> Sse2.Add(x, y); // _mm_add_epi32
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Xor(__m128i x, __m128i y)
-				=> Sse2.Xor(x, y); // _mm_xor_si128
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Or(__m128i x, __m128i y)
-				=> Sse2.Or(x, y); // _mm_or_si128
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Mul(__m128i x, __m128i y)
-				=> Sse41.MultiplyLow(x, y); // _mm_mullo_epi32
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Mul5(__m128i x)
-				=> Add(
-					x,
-					Sse2.ShiftLeftLogical(x, 2) // _mm_slli_epi32
-				);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Rotate(__m128i x, byte c)
-				=> Or(
-					Sse2.ShiftLeftLogical(x, c),// _mm_slli_epi32
-					Sse2.ShiftRightLogical(x, (byte)(32 - c)) // _mm_srli_epi32
-				);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Rot17(__m128i x)
-				=> Rotate(x, 17);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Rot19(__m128i x)
-				=> Rotate(x, 19);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Shuffle0321(__m128i x)
-				=> Sse2.Shuffle(x, (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)); // _mm_shuffle_epi32
-
 			public static unsafe uint Hash32(byte* s, uint len)
 			{
 				const uint seed = 81;
@@ -135,7 +88,7 @@ public static unsafe uint Hash32(byte* s, uint len)
 					__m128i be = Add(b, Mul(e, cc1));
 					h = Add(h, f);
 					f = Add(f, h);
-					h = Add(Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h))))), e);
+					h = Add(Add(k, Mul5(Rol19(Xor(Mul(Rol17(Mul(d, cc1)), cc2), (h))))), e);
 					k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
 					g = Add(Xor(c, g), a);
 					f = Add(Xor(be, f), d);
@@ -170,7 +123,7 @@ public static unsafe uint Hash32(byte* s, uint len)
 						__m128i be = Add(b, Mul(e, cc1));
 						h = Add(h, f);
 						f = Add(f, h);
-						h = Add(Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h))))), e);
+						h = Add(Add(k, Mul5(Rol19(Xor(Mul(Rol17(Mul(d, cc1)), cc2), (h))))), e);
 						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
 						g = Add(Xor(c, g), a);
 						f = Add(Xor(be, f), d);
@@ -200,7 +153,7 @@ public static unsafe uint Hash32(byte* s, uint len)
 						__m128i be = Add(b, Mul(e, cc1));
 						h = Add(h, f);
 						f = Add(f, h);
-						h = Add(Add(k, Mul5(Rot19(Xor(Mul(Rot17(Mul(d, cc1)), cc2), (h))))), e);
+						h = Add(Add(k, Mul5(Rol19(Xor(Mul(Rol17(Mul(d, cc1)), cc2), (h))))), e);
 						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); // _mm_shuffle_epi8
 						g = Add(Xor(c, g), a);
 						f = Add(Xor(be, f), d);
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
index 8b1e173d7..2c00afa59 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
@@ -39,52 +39,6 @@ internal partial class FarmHash
 	{
 		internal static class SU
 		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static unsafe __m128i Fetch128(byte* s)
-				=> Sse2.LoadVector128(s).AsUInt32(); // _mm_loadu_si128
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Add(__m128i x, __m128i y)
-				=> Sse2.Add(x, y); // _mm_add_epi32
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Xor(__m128i x, __m128i y)
-				=> Sse2.Xor(x, y); // _mm_xor_si128
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Or(__m128i x, __m128i y)
-				=> Sse2.Or(x, y); // _mm_or_si128
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Mul(__m128i x, __m128i y)
-				=> Sse41.MultiplyLow(x, y); // _mm_mullo_epi32
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Mul5(__m128i x)
-				=> Add(
-					x,
-					Sse2.ShiftLeftLogical(x, 2) // _mm_slli_epi32
-				);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i RotateLeft(__m128i x, byte c)
-				=> Or(
-					Sse2.ShiftLeftLogical(x, c),// _mm_slli_epi32
-					Sse2.ShiftRightLogical(x, (byte)(32 - c)) // _mm_srli_epi32
-				);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Rol17(__m128i x)
-				=> RotateLeft(x, 17);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Rol19(__m128i x)
-				=> RotateLeft(x, 19);
-
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static __m128i Shuffle0321(__m128i x)
-				=> Sse2.Shuffle(x, (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)); // _mm_shuffle_epi32
-
 			[MethodImpl(MethodImplOptions.AggressiveInlining)]
 			private static void swap(ref __m128i left, ref __m128i right)
 			{
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs b/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
index 2b2ccb248..09fe98bd3 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
@@ -36,14 +36,6 @@ internal partial class FarmHash
 	{
 		private static class UO
 		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static void swap(ref ulong left, ref ulong right)
-			{
-				var temp = left;
-				left = right;
-				right = temp;
-			}
-
 			[MethodImpl(MethodImplOptions.AggressiveInlining)]
 			private static unsafe ulong H(ulong x, ulong y, ulong mul, int r)
 			{
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.cs b/src/MsgPack.Abstraction/Internal/FarmHash.cs
index 29847e39f..6e9b1bac2 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.cs
@@ -115,20 +115,11 @@ private static uint InitializeRandomSeed()
 		private static unsafe uint Fetch32(byte* p)
 			=> *(uint*)p;
 
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static unsafe ulong Fetch64(byte* p)
-			=> *(ulong*)p;
-
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		private static uint Rotate32(uint val, int shift)
 			// Avoid shifting by 32: doing so yields an undefined result.
 			=> shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
 
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static ulong Rotate64(ulong val, int shift)
-			// Avoid shifting by 64: doing so yields an undefined result.
-			=> shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
-
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		private static uint fmix(uint h)
 		{

From b0a9b9c28baf7d26f239738a47e42cc4bf37863f Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 15 Jul 2020 20:33:24 +0900
Subject: [PATCH 45/82] Pascalize method name

---
 src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs | 2 +-
 src/MsgPack.Abstraction/Internal/FarmHash.MK.cs          | 6 +++---
 src/MsgPack.Abstraction/Internal/FarmHash.NA.cs          | 4 ++--
 src/MsgPack.Abstraction/Internal/FarmHash.SU.cs          | 6 +++---
 src/MsgPack.Abstraction/Internal/FarmHash.UO.cs          | 4 ++--
 src/MsgPack.Abstraction/Internal/FarmHash.cs             | 2 +-
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs b/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs
index 342835e76..705e763d5 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.IntelCommon.cs
@@ -68,7 +68,7 @@ private static Vector128<uint> Shuffle0321(Vector128<uint> x)
 			=> Sse2.Shuffle(x, (0 << 6) + (3 << 4) + (2 << 2) + (1 << 0)); // _mm_shuffle_epi32
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static void swap(ref ulong left, ref ulong right)
+		private static void Swap(ref ulong left, ref ulong right)
 		{
 			var temp = left;
 			left = right;
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs b/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs
index f015478d8..43f0a1e96 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.MK.cs
@@ -48,7 +48,7 @@ internal static unsafe uint Hash32Len13to24(byte* s, uint len, uint seed = 0)
 				h = Mur(e, h) + a;
 				a = Rotate32(a + f, 12) + d;
 				h = Mur(b ^ seed, h) + a;
-				return fmix(h);
+				return Fmix(h);
 			}
 
 			internal static unsafe uint Hash32Len0to4(byte* s, uint len, uint seed = 0)
@@ -61,7 +61,7 @@ internal static unsafe uint Hash32Len0to4(byte* s, uint len, uint seed = 0)
 					b = b * c1 + v;
 					c ^= b;
 				}
-				return fmix(Mur(b, Mur(len, c)));
+				return Fmix(Mur(b, Mur(len, c)));
 			}
 
 			internal static unsafe uint Hash32Len5to12(byte* s, uint len, uint seed = 0)
@@ -70,7 +70,7 @@ internal static unsafe uint Hash32Len5to12(byte* s, uint len, uint seed = 0)
 				a += Fetch32(s);
 				b += Fetch32(s + len - 4);
 				c += Fetch32(s + ((len >> 1) & 4));
-				return fmix(seed ^ Mur(c, Mur(b, Mur(a, d))));
+				return Fmix(seed ^ Mur(c, Mur(b, Mur(a, d))));
 			}
 
 			public static unsafe uint Hash32(byte* s, uint len)
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs b/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
index 817e70208..c9f76b8c5 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.NA.cs
@@ -204,7 +204,7 @@ public static unsafe ulong Hash64(byte* s, uint len)
 					z = Rotate64(z + w.first, 33) * k1;
 					v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
 					w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-					swap(ref z, ref x);
+					Swap(ref z, ref x);
 					s += 64;
 				} while (s != end);
 				ulong mul = k1 + ((z & 0xff) << 1);
@@ -220,7 +220,7 @@ public static unsafe ulong Hash64(byte* s, uint len)
 				z = Rotate64(z + w.first, 33) * mul;
 				v = WeakHashLen32WithSeeds(s, v.second * mul, x + w.first);
 				w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-				swap(ref z, ref x);
+				Swap(ref z, ref x);
 				return HashLen16(HashLen16(v.first, w.first, mul) + ShiftMix(y) * k0 + z,
 								 HashLen16(v.second, w.second, mul) + x,
 								 mul);
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
index 2c00afa59..7eb408425 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.SU.cs
@@ -40,7 +40,7 @@ internal partial class FarmHash
 		internal static class SU
 		{
 			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			private static void swap(ref __m128i left, ref __m128i right)
+			private static void Swap(ref __m128i left, ref __m128i right)
 			{
 				var temp = left;
 				left = right;
@@ -146,7 +146,7 @@ public static unsafe uint Hash32(byte* s, uint len)
 						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); //_mm_shuffle_epi8      
 						g = Add(Xor(c, g), a);
 						f = Add(Xor(be, f), d);
-						swap(ref f, ref q);
+						Swap(ref f, ref q);
 						q = Aes.InverseMixColumns(q.AsByte()).AsUInt32(); // _mm_aesimc_si128                
 						k = Add(k, be);
 						k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32());
@@ -181,7 +181,7 @@ public static unsafe uint Hash32(byte* s, uint len)
 						k = Xor(k, Ssse3.Shuffle(g.AsByte(), f.AsByte()).AsUInt32()); //_mm_shuffle_epi8      
 						g = Add(Xor(c, g), a);
 						f = Add(Xor(be, f), d);
-						swap(ref f, ref q);
+						Swap(ref f, ref q);
 						q = Aes.InverseMixColumns(q.AsByte()).AsUInt32(); // _mm_aesimc_si128                
 						k = Add(k, be);
 						k = Add(k, Ssse3.Shuffle(f.AsByte(), h.AsByte()).AsUInt32());
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs b/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
index 09fe98bd3..ae087da0a 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.UO.cs
@@ -98,7 +98,7 @@ private static unsafe ulong Hash64WithSeeds(byte* s, uint len,
 					z += w.second;
 					w.second += z;
 					z *= 9;
-					swap(ref u, ref y);
+					Swap(ref u, ref y);
 
 					z += a0 + a6;
 					v.first += a2;
@@ -115,7 +115,7 @@ private static unsafe ulong Hash64WithSeeds(byte* s, uint len,
 					w.second += x - y;
 					x += w.second;
 					w.second = Rotate64(w.second, 34);
-					swap(ref u, ref z);
+					Swap(ref u, ref z);
 					s += 64;
 				} while (s != end);
 				// Make s point to the last 64 bytes of input.
diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.cs b/src/MsgPack.Abstraction/Internal/FarmHash.cs
index 6e9b1bac2..c0ee6d243 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.cs
@@ -121,7 +121,7 @@ private static uint Rotate32(uint val, int shift)
 			=> shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
-		private static uint fmix(uint h)
+		private static uint Fmix(uint h)
 		{
 			h ^= h >> 16;
 			h *= 0x85ebca6b;

From b5fe7ae4c777480c1d06d6ca21a747a45a6384e8 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 15 Jul 2020 20:34:13 +0900
Subject: [PATCH 46/82] Use MethodImplOptionsShim for SSE independent path

---
 src/MsgPack.Abstraction/Internal/FarmHash.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FarmHash.cs b/src/MsgPack.Abstraction/Internal/FarmHash.cs
index c0ee6d243..63865d04b 100644
--- a/src/MsgPack.Abstraction/Internal/FarmHash.cs
+++ b/src/MsgPack.Abstraction/Internal/FarmHash.cs
@@ -111,16 +111,16 @@ private static uint InitializeRandomSeed()
 			return BinaryPrimitives.ReadUInt32LittleEndian(bytes);
 		}
 
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		private static unsafe uint Fetch32(byte* p)
 			=> *(uint*)p;
 
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		private static uint Rotate32(uint val, int shift)
 			// Avoid shifting by 32: doing so yields an undefined result.
 			=> shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
 
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		private static uint Fmix(uint h)
 		{
 			h ^= h >> 16;
@@ -131,7 +131,7 @@ private static uint Fmix(uint h)
 			return h;
 		}
 
-		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		private static uint Mur(uint a, uint h)
 		{
 			// Helper from Murmur3 for combining two 32-bit values.

From b10a8543177a8cf524c82eac1b523f60fe242e1a Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 15 Jul 2020 20:35:42 +0900
Subject: [PATCH 47/82] Code cleanup

---
 src/MsgPack.Abstraction/ExtensionType.cs       | 2 +-
 src/MsgPack.Abstraction/ExtensionTypeObject.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack.Abstraction/ExtensionType.cs b/src/MsgPack.Abstraction/ExtensionType.cs
index 1dd4e92b7..99f0931e8 100644
--- a/src/MsgPack.Abstraction/ExtensionType.cs
+++ b/src/MsgPack.Abstraction/ExtensionType.cs
@@ -22,7 +22,7 @@ namespace MsgPack
 		public ulong Tag { get; }
 
 		/// <summary>
-		///		Initializes new instance.
+		///		Initializes a new <see cref="ExtensionType"/> instance.
 		///		This constructor should not be called from application directly.
 		/// </summary>
 		/// <param name="tag">Raw tag data.</param>
diff --git a/src/MsgPack.Abstraction/ExtensionTypeObject.cs b/src/MsgPack.Abstraction/ExtensionTypeObject.cs
index e3b0b0962..3296250a4 100644
--- a/src/MsgPack.Abstraction/ExtensionTypeObject.cs
+++ b/src/MsgPack.Abstraction/ExtensionTypeObject.cs
@@ -28,7 +28,7 @@ public readonly struct ExtensionTypeObject
 		public ReadOnlySequence<byte> Body { get; }
 
 		/// <summary>
-		///		Initializes a new instance.
+		///		Initializes a new <see cref="ExtensionTypeObject"/> instance.
 		/// </summary>
 		/// <param name="type">Codec specific type of this extension type data.</param>
 		/// <param name="body">Byte sequence which is body of this extension type data.</param>

From 06d3d437433d9d94aa8008aae300ade53c2976c9 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 3 Oct 2020 23:51:31 +0900
Subject: [PATCH 48/82] Move constants definitions to .target

$TargetFramework is determined in individual .csproj files, so constants
definitions which depend on $TargetFramework do not work property.
---
 .editorconfig           |  2 +-
 Directory.Build.props   | 18 ------------------
 Directory.Build.targets | 25 +++++++++++++++++++++++++
 3 files changed, 26 insertions(+), 19 deletions(-)
 create mode 100644 Directory.Build.targets

diff --git a/.editorconfig b/.editorconfig
index c28041544..d3df05e77 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -20,7 +20,7 @@ indent_style = tab
 tab_width = 4
 
 # 2 space indentation
-[*.{xml,csproj}]
+[*.{xml,csproj,props,targets}]
 indent_style = space
 indent_size = 2
 
diff --git a/Directory.Build.props b/Directory.Build.props
index 750f3f75c..8fa47686c 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -7,22 +7,4 @@
     <RootNamespace>MsgPack</RootNamespace>
     <Nullable>enable</Nullable>
   </PropertyGroup>
-  <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
-    <DefineConstants>$(DefineConstants);UNITY;AOT</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition="!$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
-    <DefineConstants>$(DefineConstants);LIBRARY</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(TargetFramework)' != 'net35'">
-    <DefineConstants>$(DefineConstants);FEATURE_READ_ONLY_COLLECTION;FEATURE_TAP</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.1'">
-    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
-    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition="('$(TargetFramework)' == 'net5') or ('$(TargetFramework)' == 'net6')">
-    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ENCODING_EXTENSION;FEATURE_UTF8STRING</DefineConstants>
-  </PropertyGroup>
 </Project>
diff --git a/Directory.Build.targets b/Directory.Build.targets
new file mode 100644
index 000000000..1771b1d01
--- /dev/null
+++ b/Directory.Build.targets
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
+    <DefineConstants>$(DefineConstants);UNITY;AOT</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="!$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
+    <DefineConstants>$(DefineConstants);LIBRARY</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' != 'net35'">
+    <DefineConstants>$(DefineConstants);FEATURE_READ_ONLY_COLLECTION;FEATURE_ISET;FEATURE_TAP;FEATURE_EXCEPTION_DISPATCH_INFO;FEATURE_TUPLE</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net35' or '$(TargetFramework)' == 'netstandard2.0'">
+    <!-- CLR 2 and CLR 4 -->
+    <DefineConstants>$(DefineConstants);FEATURE_CER;FEATURE_CODE_ACCESS_SECURITY</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.1'">
+    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ADVANCED_BIT_CONVERTER;FEATURE_DO_NOT_WRAP_EXCEPTIONS</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ADVANCED_BIT_CONVERTER;FEATURE_DO_NOT_WRAP_EXCEPTIONS</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="('$(TargetFramework)' == 'net5') or ('$(TargetFramework)' == 'net6')">
+    <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ADVANCED_BIT_CONVERTER;FEATURE_DO_NOT_WRAP_EXCEPTIONS;FEATURE_ENCODING_EXTENSION;FEATURE_UTF8STRING;FEATURE_ADVANCED_OBSOLETE</DefineConstants>
+  </PropertyGroup>
+</Project>

From bd40ac364f4a19a0485a663bf1eb30a06eaf9eab Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 3 Oct 2020 23:51:52 +0900
Subject: [PATCH 49/82] Add addtional metadata to .props

---
 Directory.Build.props | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Directory.Build.props b/Directory.Build.props
index 8fa47686c..f56a38d8b 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -6,5 +6,10 @@
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <RootNamespace>MsgPack</RootNamespace>
     <Nullable>enable</Nullable>
+    <NeutralLanguage>en-US</NeutralLanguage>
+    <Product>MessagePack</Product>
+    <Copyright>Copyright © FUJIWARA, Yusuke and all contributors</Copyright>
+    <Version>2.0.0.0</Version>
+    <InformationalVersion>2.0.0-nightly</InformationalVersion>
   </PropertyGroup>
 </Project>

From 5dcee8679696a53206a8dcfc60445bfd0c4c03bb Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 3 Oct 2020 23:53:28 +0900
Subject: [PATCH 50/82] Add AssemblyMetadataAttribute to debug packaging

By embedding target framework info to the output dll, debugging for
packaging issue may be improved.
---
 Directory.Build.targets | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Directory.Build.targets b/Directory.Build.targets
index 1771b1d01..d2f317c09 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -22,4 +22,10 @@
   <PropertyGroup Condition="('$(TargetFramework)' == 'net5') or ('$(TargetFramework)' == 'net6')">
     <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ADVANCED_BIT_CONVERTER;FEATURE_DO_NOT_WRAP_EXCEPTIONS;FEATURE_ENCODING_EXTENSION;FEATURE_UTF8STRING;FEATURE_ADVANCED_OBSOLETE</DefineConstants>
   </PropertyGroup>
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute" Condition="'$(TargetFramework)' != 'net35'">
+      <_Parameter1>TargetFramework</_Parameter1>
+      <_Parameter2>$(TargetFramework)</_Parameter2>
+    </AssemblyAttribute>
+  </ItemGroup>
 </Project>

From 692653674dbd1fe47fa1eb5cc361c68e18a6d5d2 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 3 Oct 2020 23:56:05 +0900
Subject: [PATCH 51/82] FIX Add addtional metadata to .props

---
 src/CommonAssemblyInfo.cs | 44 +++++----------------------------------
 1 file changed, 5 insertions(+), 39 deletions(-)

diff --git a/src/CommonAssemblyInfo.cs b/src/CommonAssemblyInfo.cs
index 51ac2d17d..b28a25074 100644
--- a/src/CommonAssemblyInfo.cs
+++ b/src/CommonAssemblyInfo.cs
@@ -1,47 +1,13 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 // Universal informations for entire MsgPack for CLI.
 
 using System;
-using System.Reflection;
-using System.Resources;
 using System.Runtime.InteropServices;
 
-[assembly: AssemblyCopyright( "Copyright © FUJIWARA, Yusuke 2010-2017" )]
-[assembly: AssemblyProduct( "MessagePack" )]
-[assembly: CLSCompliant( true )]
-[assembly: ComVisible( false )]
-[assembly: NeutralResourcesLanguage( "en-US" )]
+[assembly: CLSCompliant(true)]
+[assembly: ComVisible(false)]
 
-// This version represents API compatibility.
-//   Major : Represents Major update like re-architecting, remove obsoleted APIs etc.
-//   Minor : Represents Minor update like adding new feature, obsoleting APIs, fix specification issues, etc.
-//   Build/Revision : Always 0 since CLI implementations does not care these number, so these changes cause some binding failures.
-[assembly: AssemblyVersion( "1.0.0.0" )]
-
-// This version represents libarary 'version' for human beings.
-//   Major : Same as AssemblyVersion.
-//   Minor : Same as AssemblyVersion.
-//   Build : Bug fixes and improvements, which does not break API contract, but may break some code depends on internal implementation behaviors.
-//           For example, some programs use reflection to retrieve private fields, analyse human readable exception messages or stack trace, or so.
-//   Revision : Reserced. It might be used to indicate target platform or patch.
-[assembly: AssemblyInformationalVersion( "1.0.0-dev" )]
 

From 4e91318dbcef8263fca7972a885f68cde4217e9e Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Sat, 3 Oct 2020 23:57:41 +0900
Subject: [PATCH 52/82] TODO REBASE Migrate CommonAssemblyInfo to props

It is better to consolidate assembly metadata to msbuild rather than
.cs files.
---
 Directory.Build.props     |  8 ++++++++
 src/CommonAssemblyInfo.cs | 13 -------------
 2 files changed, 8 insertions(+), 13 deletions(-)
 delete mode 100644 src/CommonAssemblyInfo.cs

diff --git a/Directory.Build.props b/Directory.Build.props
index f56a38d8b..87f862308 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -12,4 +12,12 @@
     <Version>2.0.0.0</Version>
     <InformationalVersion>2.0.0-nightly</InformationalVersion>
   </PropertyGroup>
+  <ItemGroup>
+    <AssemblyAttribute Include="System.CLSCompliantAttribute">
+      <_Parameter1>true</_Parameter1>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.InteropServices.ComVisibleAttribute">
+      <_Parameter1>false</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
 </Project>
diff --git a/src/CommonAssemblyInfo.cs b/src/CommonAssemblyInfo.cs
deleted file mode 100644
index b28a25074..000000000
--- a/src/CommonAssemblyInfo.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-// Universal informations for entire MsgPack for CLI.
-
-using System;
-using System.Runtime.InteropServices;
-
-[assembly: CLSCompliant(true)]
-[assembly: ComVisible(false)]
-
-

From 18d2d5922065988bcbb8ed9f2a778db0537a3400 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Mon, 5 Oct 2020 19:15:31 +0900
Subject: [PATCH 53/82] Revert "TODO REBASE Migrate CommonAssemblyInfo to
 props"

This reverts commit 4e91318dbcef8263fca7972a885f68cde4217e9e.
---
 Directory.Build.props     |  8 --------
 Directory.Build.targets   |  1 +
 src/CommonAssemblyInfo.cs | 13 +++++++++++++
 3 files changed, 14 insertions(+), 8 deletions(-)
 create mode 100644 src/CommonAssemblyInfo.cs

diff --git a/Directory.Build.props b/Directory.Build.props
index 87f862308..f56a38d8b 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -12,12 +12,4 @@
     <Version>2.0.0.0</Version>
     <InformationalVersion>2.0.0-nightly</InformationalVersion>
   </PropertyGroup>
-  <ItemGroup>
-    <AssemblyAttribute Include="System.CLSCompliantAttribute">
-      <_Parameter1>true</_Parameter1>
-    </AssemblyAttribute>
-    <AssemblyAttribute Include="System.Runtime.InteropServices.ComVisibleAttribute">
-      <_Parameter1>false</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
 </Project>
diff --git a/Directory.Build.targets b/Directory.Build.targets
index d2f317c09..c03ac8134 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -23,6 +23,7 @@
     <DefineConstants>$(DefineConstants);FEATURE_ASYNC_DISPOSABLE;FEATURE_ADVANCED_BIT_CONVERTER;FEATURE_DO_NOT_WRAP_EXCEPTIONS;FEATURE_ENCODING_EXTENSION;FEATURE_UTF8STRING;FEATURE_ADVANCED_OBSOLETE</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="../Common/CommonAssemblyInfo.cs" Link="Properties/CommonAssemblyInfo.cs" />
     <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute" Condition="'$(TargetFramework)' != 'net35'">
       <_Parameter1>TargetFramework</_Parameter1>
       <_Parameter2>$(TargetFramework)</_Parameter2>
diff --git a/src/CommonAssemblyInfo.cs b/src/CommonAssemblyInfo.cs
new file mode 100644
index 000000000..b28a25074
--- /dev/null
+++ b/src/CommonAssemblyInfo.cs
@@ -0,0 +1,13 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// Universal informations for entire MsgPack for CLI.
+
+using System;
+using System.Runtime.InteropServices;
+
+[assembly: CLSCompliant(true)]
+[assembly: ComVisible(false)]
+
+

From 7626c392e092ba5cdf51c3fa91062b20c0fddd05 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:02:52 +0900
Subject: [PATCH 54/82] Define FEATURE_BINARY_SERIALIZATION

---
 Directory.Build.targets                            |  3 +++
 .../InsufficientInputException.cs                  | 12 ++++++++++++
 src/MsgPack.Abstraction/LimitExceededException.cs  | 12 ++++++++++++
 src/MsgPack/MessageNotSupportedException.cs        | 13 +++++++------
 src/MsgPack/MessagePackObject.Utilities.cs         |  5 +++--
 src/MsgPack/MessagePackObjectDictionary.cs         |  7 +++++--
 src/MsgPack/MessagePackString.cs                   |  6 +++---
 src/MsgPack/MessageTypeException.cs                | 14 +++++++-------
 8 files changed, 52 insertions(+), 20 deletions(-)

diff --git a/Directory.Build.targets b/Directory.Build.targets
index c03ac8134..4b45b5873 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -6,6 +6,9 @@
   <PropertyGroup Condition="!$([System.Text.RegularExpressions.Regex]::IsMatch('%(DefineConstants)', '(^|;)UNITY[^;]*($|;)'))">
     <DefineConstants>$(DefineConstants);LIBRARY</DefineConstants>
   </PropertyGroup>
+  <PropertyGroup>
+    <DefineConstants>$(DefineConstants);FEATURE_BINARY_SERIALIZATION</DefineConstants>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(TargetFramework)' != 'net35'">
     <DefineConstants>$(DefineConstants);FEATURE_READ_ONLY_COLLECTION;FEATURE_ISET;FEATURE_TAP;FEATURE_EXCEPTION_DISPATCH_INFO;FEATURE_TUPLE</DefineConstants>
   </PropertyGroup>
diff --git a/src/MsgPack.Abstraction/InsufficientInputException.cs b/src/MsgPack.Abstraction/InsufficientInputException.cs
index ea02c15ae..857b66460 100644
--- a/src/MsgPack.Abstraction/InsufficientInputException.cs
+++ b/src/MsgPack.Abstraction/InsufficientInputException.cs
@@ -3,12 +3,18 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+#if FEATURE_BINARY_SERIALIZATION
+using System.Runtime.Serialization;
+#endif // FEATURE_BINARY_SERIALIZATION
 
 namespace MsgPack
 {
 	/// <summary>
 	///		An exception thrown if there are no more inputs when be requested.
 	/// </summary>
+#if FEATURE_BINARY_SERIALIZATION
+	[Serializable]
+#endif // FEATURE_BINARY_SERIALIZATION
 	public sealed class InsufficientInputException : Exception
 	{
 		public InsufficientInputException()
@@ -19,5 +25,11 @@ public InsufficientInputException(string? message)
 
 		public InsufficientInputException(string? message, Exception? innerException)
 			: base(message, innerException) { }
+#if FEATURE_BINARY_SERIALIZATION
+
+		private InsufficientInputException(SerializationInfo info, StreamingContext context)
+			: base(info, context) { }
+
+#endif // FEATURE_BINARY_SERIALIZATION
 	}
 }
diff --git a/src/MsgPack.Abstraction/LimitExceededException.cs b/src/MsgPack.Abstraction/LimitExceededException.cs
index 19ef6a106..1fb5841be 100644
--- a/src/MsgPack.Abstraction/LimitExceededException.cs
+++ b/src/MsgPack.Abstraction/LimitExceededException.cs
@@ -3,9 +3,15 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+#if FEATURE_BINARY_SERIALIZATION
+using System.Runtime.Serialization;
+#endif // FEATURE_BINARY_SERIALIZATION
 
 namespace MsgPack
 {
+#if FEATURE_BINARY_SERIALIZATION
+	[Serializable]
+#endif // FEATURE_BINARY_SERIALIZATION
 	public sealed class LimitExceededException : Exception
 	{
 		public LimitExceededException()
@@ -16,5 +22,11 @@ public LimitExceededException(string? message)
 
 		public LimitExceededException(string? message, Exception? innerException)
 			: base(message, innerException) { }
+#if FEATURE_BINARY_SERIALIZATION
+
+		private LimitExceededException(SerializationInfo info, StreamingContext context)
+			: base(info, context) { }
+
+#endif // FEATURE_BINARY_SERIALIZATION
 	}
 }
diff --git a/src/MsgPack/MessageNotSupportedException.cs b/src/MsgPack/MessageNotSupportedException.cs
index 1ef21ad74..5c3f5f567 100644
--- a/src/MsgPack/MessageNotSupportedException.cs
+++ b/src/MsgPack/MessageNotSupportedException.cs
@@ -19,18 +19,18 @@
 #endregion -- License Terms --
 
 using System;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_BINARY_SERIALIZATION
 using System.Runtime.Serialization;
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_BINARY_SERIALIZATION
 
 namespace MsgPack
 {
 	/// <summary>
 	///		Exception occurs when serialized stream contains structures or features which will never be supported by MsgPack/CLI implementation.
 	/// </summary>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_BINARY_SERIALIZATION
 	[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_BINARY_SERIALIZATION
 	public sealed class MessageNotSupportedException : Exception
 	{
 		/// <summary>
@@ -53,7 +53,7 @@ public MessageNotSupportedException(string? message) : this(message, null) { }
 		/// </param>
 		public MessageNotSupportedException(string? message, Exception? inner) : base(message ?? "Specified object is not supported.", inner) { }
 
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_BINARY_SERIALIZATION
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageNotSupportedException"/> class with serialized data.
 		/// </summary>
@@ -70,6 +70,7 @@ public MessageNotSupportedException(string? message, Exception? inner) : base(me
 		///	</exception>
 		private MessageNotSupportedException(SerializationInfo info, StreamingContext context)
 			: base(info, context) { }
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+
+#endif // FEATURE_BINARY_SERIALIZATION
 	}
 }
diff --git a/src/MsgPack/MessagePackObject.Utilities.cs b/src/MsgPack/MessagePackObject.Utilities.cs
index 545fe5486..6c9cf2354 100644
--- a/src/MsgPack/MessagePackObject.Utilities.cs
+++ b/src/MsgPack/MessagePackObject.Utilities.cs
@@ -44,9 +44,10 @@
 
 namespace MsgPack
 {
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !NETSTANDARD2_0
+#if FEATURE_BINARY_SERIALIZATION
+#warning TODO: Enable in .NET Standard 2.0 in Changes.txt
 	[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !NETSTANDARD2_0
+#endif // FEATURE_BINARY_SERIALIZATION
 	partial struct MessagePackObject : IPackable
 #if FEATURE_TAP
 		, IAsyncPackable
diff --git a/src/MsgPack/MessagePackObjectDictionary.cs b/src/MsgPack/MessagePackObjectDictionary.cs
index 9a244f73d..b1570b301 100644
--- a/src/MsgPack/MessagePackObjectDictionary.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.cs
@@ -34,6 +34,9 @@
 #endif // FEATURE_MPCONTRACT
 using System.Globalization;
 using System.Linq;
+#if FEATURE_BINARY_SERIALIZATION
+using System.Runtime.CompilerServices;
+#endif // FEATURE_BINARY_SERIALIZATION
 
 namespace MsgPack
 {
@@ -45,9 +48,9 @@ namespace MsgPack
 	///		Additionally, this dictionary implements 'freezing' feature. 
 	///		For details, see <see cref="IsFrozen"/>, <see cref="Freeze"/>, and <see cref="AsFrozen"/>.
 	/// </remarks>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_BINARY_SERIALIZATION
 	[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_BINARY_SERIALIZATION
 	[DebuggerTypeProxy( typeof( DictionaryDebuggerProxy<,> ) )]
 	public partial class MessagePackObjectDictionary :
 		IDictionary<MessagePackObject, MessagePackObject>, IDictionary
diff --git a/src/MsgPack/MessagePackString.cs b/src/MsgPack/MessagePackString.cs
index ad8b45e5d..bad41a443 100644
--- a/src/MsgPack/MessagePackString.cs
+++ b/src/MsgPack/MessagePackString.cs
@@ -43,10 +43,10 @@ namespace MsgPack
 	/// <summary>
 	///		Encapselates <see cref="String"/> and its serialized UTF-8 bytes.
 	/// </summary>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !NETSTANDARD2_0
+#if FEATURE_BINARY_SERIALIZATION
+#warning TODO: Enable in .NET Standard 2.0 in Changes.txt
 	[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3 && !NETSTANDARD2_0
-#if !NET35 && !UNITY
+#endif // FEATURE_BINARY_SERIALIZATION
 	[SecuritySafeCritical]
 #endif // !NET35 && !UNITY
 	[DebuggerDisplay( "{DebuggerDisplayString}" )]
diff --git a/src/MsgPack/MessageTypeException.cs b/src/MsgPack/MessageTypeException.cs
index 7f00d2ba5..6ce2e5c39 100644
--- a/src/MsgPack/MessageTypeException.cs
+++ b/src/MsgPack/MessageTypeException.cs
@@ -19,19 +19,18 @@
 #endregion -- License Terms --
 
 using System;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_BINARY_SERIALIZATION
 using System.Runtime.Serialization;
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_BINARY_SERIALIZATION
 
 namespace MsgPack
 {
 	/// <summary>
 	///		Represents unpacking error when message type is unknown or unavailable.
 	/// </summary>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_BINARY_SERIALIZATION
 	[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-	public class MessageTypeException : Exception
+#endif // FEATURE_BINARY_SERIALIZATION
 	{
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with the default error message.
@@ -52,8 +51,8 @@ public MessageTypeException(string? message) : this(message, null) { }
 		///		The exception that is the cause of the current exception, or a <c>null</c> if no inner exception is specified.
 		/// </param>
 		public MessageTypeException(string? message, Exception? inner) : base(message ?? "Invalid message type.", inner) { }
+#if FEATURE_BINARY_SERIALIZATION
 
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with serialized data.
 		/// </summary>
@@ -69,6 +68,7 @@ public MessageTypeException(string? message, Exception? inner) : base(message ??
 		///		The class name is <c>null</c> or <see cref="P:HResult"/> is zero (0).
 		///	</exception>
 		protected MessageTypeException(SerializationInfo info, StreamingContext context) : base(info, context) { }
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+
+#endif // FEATURE_BINARY_SERIALIZATION
 	}
 }

From 0ad0ba0d1d9ceb1900007cbbf2575425e88b6580 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:05:03 +0900
Subject: [PATCH 55/82] Fix ExtensionType.Tag type to long

MessagePack specification defines timestamp as -1 instead of 0xFF,
that means that the specification defines type code as signed.
---
 src/MsgPack.Abstraction/ExtensionType.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack.Abstraction/ExtensionType.cs b/src/MsgPack.Abstraction/ExtensionType.cs
index 99f0931e8..08e7cb6e6 100644
--- a/src/MsgPack.Abstraction/ExtensionType.cs
+++ b/src/MsgPack.Abstraction/ExtensionType.cs
@@ -19,7 +19,7 @@ namespace MsgPack
 		/// <remarks>
 		///		Valid range and sementics depend on serialization codec.
 		/// </remarks>
-		public ulong Tag { get; }
+		public long Tag { get; }
 
 		/// <summary>
 		///		Initializes a new <see cref="ExtensionType"/> instance.
@@ -27,7 +27,7 @@ namespace MsgPack
 		/// </summary>
 		/// <param name="tag">Raw tag data.</param>
 		[EditorBrowsable(EditorBrowsableState.Never)]
-		public ExtensionType(ulong tag)
+		public ExtensionType(long tag)
 		{
 			this.Tag = tag;
 		}

From 7265edab7a72d9cfc5fd473bfa6f858f05b4c956 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:05:28 +0900
Subject: [PATCH 56/82] Move CommonAssemblyInfo.cs to Common/

---
 src/{ => Common}/CommonAssemblyInfo.cs | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/{ => Common}/CommonAssemblyInfo.cs (100%)

diff --git a/src/CommonAssemblyInfo.cs b/src/Common/CommonAssemblyInfo.cs
similarity index 100%
rename from src/CommonAssemblyInfo.cs
rename to src/Common/CommonAssemblyInfo.cs

From a6b46bc40579c94908d68c71111ffe7fc81debcc Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:06:57 +0900
Subject: [PATCH 57/82] Change FormatFeatures to CodecFeatures

---
 .../Codecs/CodecFeatures.cs                   | 148 +++++++++
 .../Codecs/CodecFeaturesBuilder.cs            | 290 ++++++++++++++++++
 .../Internal/FormatDecoderOptions.cs          |   5 +-
 .../Internal/FormatDecoderOptionsBuilder.cs   |   2 +-
 .../Internal/FormatEncoderOptions.cs          |   5 +-
 .../Internal/FormatEncoderOptionsBuilder.cs   |   2 +-
 .../Internal/FormatFeatures.cs                |  98 ------
 .../Internal/FormatFeaturesBuilder.cs         |  26 --
 8 files changed, 446 insertions(+), 130 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/Codecs/CodecFeatures.cs
 create mode 100644 src/MsgPack.Abstraction/Codecs/CodecFeaturesBuilder.cs
 delete mode 100644 src/MsgPack.Abstraction/Internal/FormatFeatures.cs
 delete mode 100644 src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs

diff --git a/src/MsgPack.Abstraction/Codecs/CodecFeatures.cs b/src/MsgPack.Abstraction/Codecs/CodecFeatures.cs
new file mode 100644
index 000000000..4a0e4f234
--- /dev/null
+++ b/src/MsgPack.Abstraction/Codecs/CodecFeatures.cs
@@ -0,0 +1,148 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Text;
+using MsgPack.Serialization;
+
+namespace MsgPack.Codecs
+{
+	/// <summary>
+	///		Represents features of the specific codec.
+	/// </summary>
+	public sealed class CodecFeatures
+	{
+		/// <summary>
+		///		Gets a unique name of the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A unique name of the underlying codec which is non-blank string.
+		/// </value>
+		public string Name { get; }
+
+		/// <summary>
+		///		Gets a value which indicates the underlying codec supports collection length.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng codec supports collection length; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
+		///		<list type="bullet">
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, System.Threading.CancellationToken)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, out System.Int32, System.Threading.CancellationToken)"/></item>
+		///		</list>
+		/// </remarks>
+		public bool CanCountCollectionItems { get; }
+
+		/// <summary>
+		///		Gets a value which indicates the underlying codec supports custom string encoding.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng format supports custom string encoding; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, <see cref="System.Text.Encoding"/> typed parameters in <see cref="Encoder{TExtensionType}"/> and <see cref="Decoder{TExtensionType}"/> methods will be ignored.
+		/// </remarks>
+		public bool CanSpecifyStringEncoding { get; }
+
+		/// <summary>
+		///		Gets a value which indicates the underlying codec supports extension types.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng codec supports extension types; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
+		///		<list type="bullet">
+		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.ReadOnlySpan{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.Buffers.ReadOnlySequence{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeExtension(in System.Buffers.SequenceReader{System.Byte}, out TExtensionType, out System.Buffers.ReadOnlySequence{System.Byte}, out System.Int32, System.Threading.CancellationToken)(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///		</list>
+		///		In additon, <c>TExtentionType</c> type parameter should be <see cref="NullExtensionType"/>.
+		/// </remarks>
+		public bool SupportsExtensionTypes { get; }
+
+		/// <summary>
+		///		Gets a value which indicates preferred <see cref="SerializationMethod"/> for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates preferred <see cref="SerializationMethod"/> for the underlying codec.
+		/// </value>
+		public SerializationMethod PreferredObjectSerializationMethod { get; }
+
+		/// <summary>
+		///		Gets a value which indicates preferred <see cref="EnumSerializationMethod"/> for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates preferred <see cref="EnumSerializationMethod"/> for the underlying codec.
+		/// </value>
+		public EnumSerializationMethod PreferredEnumSerializationMethod { get; }
+
+		/// <summary>
+		///		Gets a value which indicates preferred <see cref="DateTimeConversionMethod"/> for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates preferred <see cref="DateTimeConversionMethod"/> for the underlying codec.
+		/// </value>
+		public DateTimeConversionMethod PreferredDateTimeConversionMethod { get; }
+
+		/// <summary>
+		///		Gets a value which indicates available <see cref="SerializationMethod"/> set as <see cref="MsgPack.Serialization.AvailableSerializationMethods"/>.
+		/// </summary>
+		/// <value>
+		///		A value which indicates available <see cref="SerializationMethod"/> set as <see cref="MsgPack.Serialization.AvailableSerializationMethods"/>.
+		/// </value>
+		public AvailableSerializationMethods AvailableSerializationMethods { get; }
+
+		/// <summary>
+		///		Gets the default encoding of strings.
+		/// </summary>
+		/// <value>
+		///		The default encoding of strings.
+		/// </value>
+		public Encoding DefaultStringEncoding { get; }
+
+		/// <summary>
+		///		Gets the precision of fraction portion on ISO 8601 date time string as specified by this codec.
+		/// </summary>
+		/// <value>
+		///		The precision of fraction portion on ISO 8601 date time string as specified by this codec.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public int? Iso8601FractionOfSecondsPrecision { get; }
+
+		/// <summary>
+		///		Gets a separator char for fraction portion by this codec.
+		/// </summary>
+		/// <value>
+		///		A separator char for fraction portion.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		public char? Iso8601DecimalSeparator { get; }
+
+		internal CodecFeatures(CodecFeaturesBuilder builder)
+		{
+			this.Name = builder.Name;
+			this.CanCountCollectionItems = builder.CanCountCollectionItems;
+			this.CanSpecifyStringEncoding = builder.CanSpecifyStringEncoding;
+			this.SupportsExtensionTypes = builder.SupportsExtensionTypes;
+			this.PreferredObjectSerializationMethod = builder.PreferredObjectSerializationMethod;
+			this.PreferredEnumSerializationMethod = builder.PreferredEnumSerializationMethod;
+			this.PreferredDateTimeConversionMethod = builder.PreferredDateTimeConversionMethod;
+			this.AvailableSerializationMethods = builder.AvailableSerializationMethods;
+			this.DefaultStringEncoding = builder.DefaultStringEncoding;
+			this.Iso8601FractionOfSecondsPrecision = builder.Iso8601FractionOfSecondsPrecision;
+			this.Iso8601DecimalSeparator = builder.Iso8601DecimalSeparator;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Codecs/CodecFeaturesBuilder.cs b/src/MsgPack.Abstraction/Codecs/CodecFeaturesBuilder.cs
new file mode 100644
index 000000000..53f046b6a
--- /dev/null
+++ b/src/MsgPack.Abstraction/Codecs/CodecFeaturesBuilder.cs
@@ -0,0 +1,290 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Text;
+using MsgPack.Internal;
+using MsgPack.Serialization;
+
+namespace MsgPack.Codecs
+{
+	/// <summary>
+	///		A builder object for <see cref="CodecFeatures"/>.
+	/// </summary>
+	public sealed class CodecFeaturesBuilder
+	{
+		/// <summary>
+		///		Gets a unique name of the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A unique name of the underlying codec which is non-blank string.
+		/// </value>
+		public string Name { get; }
+
+		/// <summary>
+		///		Gets or sets a value which indicates the underlying codec supports collection length.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng codec supports collection length; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
+		///		<list type="bullet">
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64, out System.Int32)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, System.Threading.CancellationToken)"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, out System.Int32, System.Threading.CancellationToken)"/></item>
+		///		</list>
+		/// </remarks>
+		public bool CanCountCollectionItems { get; set; }
+
+		/// <summary>
+		///		Gets or sets a value which indicates the underlying codec supports custom string encoding.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng format supports custom string encoding; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, <see cref="System.Text.Encoding"/> typed parameters in <see cref="Encoder{TExtensionType}"/> and <see cref="Decoder{TExtensionType}"/> methods will be ignored.
+		/// </remarks>
+		public bool CanSpecifyStringEncoding { get; set; }
+
+		/// <summary>
+		///		Gets or sets a value which indicates the underlying codec supports extension types.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the underlyng codec supports extension types; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
+		///		<list type="bullet">
+		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.ReadOnlySpan{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.Buffers.ReadOnlySequence{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
+		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeExtension(in System.Buffers.SequenceReader{System.Byte}, out TExtensionType, out System.Buffers.ReadOnlySequence{System.Byte}, out System.Int32, System.Threading.CancellationToken)(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
+		///		</list>
+		///		In additon, <c>TExtentionType</c> type parameter should be <see cref="NullExtensionType"/>.
+		/// </remarks>
+		public bool SupportsExtensionTypes { get; set; }
+
+		/// <summary>
+		///		Gets a value which indicates preferred <see cref="SerializationMethod"/> for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates preferred <see cref="SerializationMethod"/> for the underlying codec.
+		/// </value>
+		public SerializationMethod PreferredObjectSerializationMethod { get; private set; }
+
+		private EnumSerializationMethod _preferredEnumSerializationMethod;
+
+		/// <summary>
+		///		Gets or sets a value which indicates preferred <see cref="EnumSerializationMethod"/> for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates preferred <see cref="EnumSerializationMethod"/> for the underlying codec.
+		/// </value>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		Setting value is not a defined <see cref="EnumSerializationMethod"/> value.
+		/// </exception>
+		public EnumSerializationMethod PreferredEnumSerializationMethod
+		{
+			get => this._preferredEnumSerializationMethod;
+			set => this._preferredEnumSerializationMethod = Ensure.Defined(value);
+		}
+
+		private DateTimeConversionMethod _preferredDateTimeConversionMethod;
+
+		/// <summary>
+		///		Gets or sets a value which indicates preferred <see cref="DateTimeConversionMethod"/> for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates preferred <see cref="DateTimeConversionMethod"/> for the underlying codec.
+		/// </value>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		Setting value is not a defined <see cref="DateTimeConversionMethod"/> value.
+		/// </exception>
+		public DateTimeConversionMethod PreferredDateTimeConversionMethod
+		{
+			get => this._preferredDateTimeConversionMethod;
+			set => this._preferredDateTimeConversionMethod = Ensure.Defined(value);
+		}
+
+		/// <summary>
+		///		Gets a value which indicates available <see cref="SerializationMethod"/> set as <see cref="AvailableSerializationMethods"/>.
+		/// </summary>
+		/// <value>
+		///		A value which indicates available <see cref="SerializationMethod"/> set as <see cref="AvailableSerializationMethods"/>.
+		/// </value>
+		public AvailableSerializationMethods AvailableSerializationMethods { get; private set; }
+
+		/// <summary>
+		///		Gets the default encoding of strings.
+		/// </summary>
+		/// <value>
+		///		The default encoding of strings.
+		/// </value>
+		public Encoding DefaultStringEncoding { get; private set; } = Utf8EncodingNonBomStrict.Instance;
+
+
+		/// <summary>
+		///		Gets the precision of fraction portion on ISO 8601 date time string as specified by this codec.
+		/// </summary>
+		/// <value>
+		///		The precision of fraction portion on ISO 8601 date time string as specified by this codec.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public int? Iso8601FractionOfSecondsPrecision { get; private set; }
+
+		/// <summary>
+		///		Gets a separator char for fraction portion for the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A separator char for fraction portion.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		public char? Iso8601DecimalSeparator { get; private set; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="CodecFeaturesBuilder"/> object.
+		/// </summary>
+		/// <param name="name">A unique name of the underlying codec. Note that <see cref="Name"/> property will be trimmed value.</param>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="name"/> is <c>null</c>.
+		/// </exception>
+		/// <exception cref="System.ArgumentException">
+		///		<paramref name="name"/> is empty or contains only white spaces.
+		/// </exception>
+		public CodecFeaturesBuilder(string name)
+		{
+			this.Name = Ensure.NotBlankAndTrimmed(name);
+		}
+
+		/// <summary>
+		///		Sets preferred and available serialization method for the underlying codec.
+		/// </summary>
+		/// <param name="preferredMethod">
+		///		A value which indicates preferred <see cref="SerializationMethod"/> for the underlying codec.
+		/// </param>
+		/// <param name="availableMethods">
+		///		A value which indicates available <see cref="SerializationMethod"/> set as <see cref="MsgPack.Serialization.AvailableSerializationMethods"/>.
+		/// </param>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		<paramref name="preferredMethod"/> value is not a defined <see cref="SerializationMethod"/> value.
+		///		<paramref name="availableMethods"/> contains any undefined <see cref="MsgPack.Serialization.AvailableSerializationMethods"/> flag value.
+		/// </exception>
+		public CodecFeaturesBuilder SetObjectSerializationMethod(
+			SerializationMethod preferredMethod,
+			AvailableSerializationMethods availableMethods
+		)
+		{
+			this.PreferredObjectSerializationMethod = Ensure.Defined(preferredMethod);
+			this.AvailableSerializationMethods = Ensure.Defined(availableMethods);
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the default encoding of strings.
+		/// </summary>
+		/// <param name="value">The default encoding of strings.</param>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="value"/> is <c>null</c>.
+		/// </exception>
+		public CodecFeaturesBuilder SetDefaultStringEncoding(Encoding value)
+		{
+			this.DefaultStringEncoding = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Resets the default encoding of strings.
+		/// </summary>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		public CodecFeaturesBuilder ResetDefaultStringEncoding()
+		{
+			this.DefaultStringEncoding = Utf8EncodingNonBomStrict.Instance;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the precision of ISO 8601 fraction of seconds portion for the underlying codec.
+		/// </summary>
+		/// <param name="value">The precision.</param>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		<paramref name="value"/> is negative value.
+		/// </exception>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public CodecFeaturesBuilder SetIso8601FractionOfSecondsPrecision(int value)
+		{
+			this.Iso8601FractionOfSecondsPrecision = Ensure.IsNotLessThan(value, 0);
+			return this;
+		}
+
+		/// <summary>
+		///		Resets the precision of ISO 8601 fraction of seconds portion for the underlying codec.
+		/// </summary>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public CodecFeaturesBuilder ResetIso8601FractionOfSecondsPrecision()
+		{
+			this.Iso8601FractionOfSecondsPrecision = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the decimal separator of ISO 8601 for the underlying codec.
+		/// </summary>
+		/// <param name="value">The precision.</param>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		<paramref name="value"/> is not <c>,</c> nor <c>.</c>.
+		/// </exception>
+		public CodecFeaturesBuilder SetIso8601DecimalSeparator(char value)
+		{
+			switch(value)
+			{
+				case ',':
+				case '.':
+				{
+					this.Iso8601DecimalSeparator = value;
+					break;
+				}
+				default:
+				{
+					Throw.InvalidIso8601DecimalSeparator(value);
+					break; // Never reaches
+				}
+			}
+
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the decimal separator of ISO 8601 for the underlying codec.
+		/// </summary>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		public CodecFeaturesBuilder ResetIso8601DecimalSeparator()
+		{
+			this.Iso8601DecimalSeparator = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Builds new instance of immutable <see cref="CodecFeatures"/> object from this builder instance.
+		/// </summary>
+		/// <returns>New instance of immutable <see cref="CodecFeatures"/> object.</returns>
+		public CodecFeatures Build() => new CodecFeatures(this);
+	}
+}
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs b/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
index 59b6aac3a..6fa191e60 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoderOptions.cs
@@ -3,6 +3,7 @@
 // See the LICENSE in the project root for more information.
 
 using System.Buffers;
+using MsgPack.Codecs;
 
 namespace MsgPack.Internal
 {
@@ -28,9 +29,9 @@ public abstract class FormatDecoderOptions
 
 		public bool ClearsBuffer { get; }
 
-		public FormatFeatures Features { get; }
+		public CodecFeatures Features { get; }
 
-		protected FormatDecoderOptions(FormatDecoderOptionsBuilder builder, FormatFeatures features)
+		protected FormatDecoderOptions(FormatDecoderOptionsBuilder builder, CodecFeatures features)
 		{
 			builder = Ensure.NotNull(builder);
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs
index 766108071..44b584d1a 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoderOptionsBuilder.cs
@@ -75,7 +75,7 @@ public ArrayPool<char> CharBufferPool
 			set => this._charBufferPool = Ensure.NotNull(value);
 		}
 
-		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
+		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBufferOnReturn;
 
 		protected FormatDecoderOptionsBuilder() { }
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs b/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
index b78dd8720..53da6645f 100644
--- a/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoderOptions.cs
@@ -3,6 +3,7 @@
 // See the LICENSE in the project root for more information.
 
 using System.Buffers;
+using MsgPack.Codecs;
 
 namespace MsgPack.Internal
 {
@@ -20,9 +21,9 @@ public abstract class FormatEncoderOptions
 
 		public bool ClearsBuffer { get; }
 
-		public FormatFeatures Features { get; }
+		public CodecFeatures Features { get; }
 
-		protected FormatEncoderOptions(FormatEncoderOptionsBuilder builder, FormatFeatures features)
+		protected FormatEncoderOptions(FormatEncoderOptionsBuilder builder, CodecFeatures features)
 		{
 			builder = Ensure.NotNull(builder);
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs
index 569966abc..d31f70499 100644
--- a/src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatEncoderOptionsBuilder.cs
@@ -48,7 +48,7 @@ public ArrayPool<char> CharBufferPool
 			set => this._charBufferPool = Ensure.NotNull(value);
 		}
 
-		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
+		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBufferOnReturn;
 
 		protected FormatEncoderOptionsBuilder() { }
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs b/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
deleted file mode 100644
index 03cd0439e..000000000
--- a/src/MsgPack.Abstraction/Internal/FormatFeatures.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using MsgPack.Serialization;
-
-namespace MsgPack.Internal
-{
-	public sealed class FormatFeatures
-	{
-#warning TODO: REMOVE
-		public bool IsContextful { get; }
-
-		public string Name { get; }
-
-		/// <summary>
-		///		Gets a value which indicates the underlying format supports collection length.
-		/// </summary>
-		/// <value>
-		///		<c>true</c>, if the underlyng format supports collection length; <c>false</c>, otherwise.
-		/// </value>
-		/// <remarks>
-		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
-		///		<list type="bullet">
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte})"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64)"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeArrayOrMapHeader(in System.Buffers.SequenceReader{System.Byte}, out System.Int64, out System.Int32)"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, System.Threading.CancellationToken)"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.Drain(in System.Buffers.SequenceReader{System.Byte}, in CollectionContext, System.Int64, out System.Int32, System.Threading.CancellationToken)"/></item>
-		///		</list>
-		/// </remarks>
-		public bool CanCountCollectionItems { get; }
-
-		/// <summary>
-		///		Gets a value which indicates the underlying format supports custom string encoding.
-		/// </summary>
-		/// <value>
-		///		<c>true</c>, if the underlyng format supports custom string encoding; <c>false</c>, otherwise.
-		/// </value>
-		/// <remarks>
-		///		When this property returns <c>false</c>, <see cref="System.Text.Encoding"/> typed parameters in <see cref="Encoder{TExtensionType}"/> and <see cref="Decoder{TExtensionType}"/> methods will be ignored.
-		/// </remarks>
-		public bool CanSpecifyStringEncoding { get; }
-
-		/// <summary>
-		///		Gets a value which indicates the underlying format supports extension types.
-		/// </summary>
-		/// <value>
-		///		<c>true</c>, if the underlyng format supports extension types; <c>false</c>, otherwise.
-		/// </value>
-		/// <remarks>
-		///		When this property returns <c>false</c>, following methods should throw <see cref="System.NotSupportedException"/>.
-		///		<list type="bullet">
-		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.ReadOnlySpan{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
-		///			<item><see cref="FormatEncoder{TExtensionType}.EncodeExtension(TExtensionType, System.Buffers.ReadOnlySequence{System.Byte}, System.Buffers.IBufferWriter{System.Byte})"/></item>
-		///			<item><see cref="FormatDecoder{TExtensionType}.DecodeExtension(in System.Buffers.SequenceReader{System.Byte}, out TExtensionType, out System.Buffers.ReadOnlySequence{System.Byte}, out System.Int32, System.Threading.CancellationToken)(in System.Buffers.SequenceReader{System.Byte}, out System.Int32)"/></item>
-		///		</list>
-		///		In additon, <c>TExtentionType</c> type parameter should be <see cref="NullExtensionType"/>.
-		/// </remarks>
-		public bool SupportsExtensionTypes { get; }
-
-		public SerializationMethod PreferredSerializationMethod { get; }
-		public AvailableSerializationMethods AvailableSerializationMethods { get; }
-
-		internal FormatFeatures(FormatFeaturesBuilder builder)
-		{
-			this.Name = builder.Name;
-			this.IsContextful = builder.IsContextful;
-			this.CanCountCollectionItems = builder.CanCountCollectionItems;
-			this.CanSpecifyStringEncoding = builder.CanSpecifyStringEncoding;
-			this.SupportsExtensionTypes = builder.SupportsExtensionTypes;
-			this.PreferredSerializationMethod = builder.PreferredSerializationMethod;
-			this.AvailableSerializationMethods = builder.AvailableSerializationMethods;
-		}
-
-		internal SerializationMethod GetSerializationMethod(SerializationMethod? contextPreferredMethod)
-		{
-			if (contextPreferredMethod == null)
-			{
-				return this.PreferredSerializationMethod;
-			}
-
-			if (contextPreferredMethod == SerializationMethod.Array && (this.AvailableSerializationMethods & AvailableSerializationMethods.Array) == 0)
-			{
-				Throw.UnavailableMethod(this.Name, SerializationMethod.Array);
-			}
-			else if ((this.AvailableSerializationMethods & AvailableSerializationMethods.Map) == 0)
-			{
-				Throw.UnavailableMethod(this.Name, SerializationMethod.Map);
-			}
-
-			return contextPreferredMethod.GetValueOrDefault();
-		}
-	}
-}
diff --git a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs b/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
deleted file mode 100644
index d08d617f9..000000000
--- a/src/MsgPack.Abstraction/Internal/FormatFeaturesBuilder.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using MsgPack.Serialization;
-
-namespace MsgPack.Internal
-{
-	public sealed class FormatFeaturesBuilder
-	{
-		public string Name { get; }
-		public bool IsContextful { get; set; }
-		public bool CanCountCollectionItems { get; set; }
-		public bool CanSpecifyStringEncoding { get; set; }
-		public bool SupportsExtensionTypes { get; set; }
-		public SerializationMethod PreferredSerializationMethod { get; set; }
-		public AvailableSerializationMethods AvailableSerializationMethods { get; set; }
-
-		public FormatFeaturesBuilder(string name)
-		{
-			this.Name = Ensure.NotBlank(name).Trim();
-		}
-
-		public FormatFeatures Build() => new FormatFeatures(this);
-	}
-}

From 29b53ce0fb2fa9af7bff724bb196822081c343f7 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:13:42 +0900
Subject: [PATCH 58/82] Port primitive types

---
 .../MsgPack.Abstraction.csproj                |   37 +
 src/MsgPack/Binary.cs                         |  124 +-
 src/MsgPack/CollectionDebuggerProxy`1.cs      |   33 +-
 src/MsgPack/CollectionOperation.cs            |  104 +-
 src/MsgPack/DictionaryDebuggerProxy`2.cs      |   42 +-
 src/MsgPack/MessageNotSupportedException.cs   |   22 +-
 src/MsgPack/MessagePackConvert.cs             |  111 +-
 src/MsgPack/MessagePackExtendedTypeObject.cs  |  158 +-
 src/MsgPack/MessagePackObject.Utilities.cs    | 1413 +++++++----------
 src/MsgPack/MessagePackObject.cs              | 1039 ++++++------
 .../MessagePackObjectDictionary.Enumerator.cs |  111 +-
 ...ePackObjectDictionary.KeySet.Enumerator.cs |   63 +-
 .../MessagePackObjectDictionary.KeySet.cs     |  231 +--
 ...ctDictionary.ValueCollection.Enumerator.cs |   62 +-
 ...agePackObjectDictionary.ValueCollection.cs |  164 +-
 src/MsgPack/MessagePackObjectDictionary.cs    |  527 +++---
 .../MessagePackObjectEqualityComparer.cs      |   59 +-
 src/MsgPack/MessagePackString.cs              |  330 ++--
 src/MsgPack/MessageTypeException.cs           |   40 +-
 19 files changed, 1765 insertions(+), 2905 deletions(-)

diff --git a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
index f5cc62568..b8660a931 100644
--- a/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
+++ b/src/MsgPack.Abstraction/MsgPack.Abstraction.csproj
@@ -7,8 +7,38 @@
   <ItemGroup>
     <Compile Include="../MsgPack/MessageNotSupportedException.cs" Link="MessageNotSupportedException.cs" />
     <Compile Include="../MsgPack/MessageTypeException.cs" Link="MessageTypeException.cs" />
+    <Compile Include="../MsgPack/Binary.cs" Link="Binary.cs" />
+    <Compile Include="../MsgPack/MessagePackExtendedTypeObject.cs" Link="MessagePackExtendedTypeObject.cs" />
+    <Compile Include="../MsgPack/MessagePackObject.Utilities.cs" Link="MessagePackObject.Utilities.cs" />
+    <Compile Include="../MsgPack/MessagePackObjectDictionary.cs" Link="MessagePackObjectDictionary.cs" />
+    <Compile Include="../MsgPack/MessagePackObjectDictionary.Enumerator.cs" Link="MessagePackObjectDictionary.Enumerator.cs" />
+    <Compile Include="../MsgPack/MessagePackObjectDictionary.KeySet.cs" Link="MessagePackObjectDictionary.KeySet.cs" />
+    <Compile Include="../MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs" Link="MessagePackObjectDictionary.KeySet.Enumerator.cs" />
+    <Compile Include="../MsgPack/MessagePackObjectDictionary.ValueCollection.cs" Link="MessagePackObjectDictionary.ValueCollection.cs" />
+    <Compile Include="../MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs" Link="MessagePackObjectDictionary.ValueCollection.Enumerator.cs" />
+    <Compile Include="../MsgPack/MessagePackString.cs" Link="MessagePackString.cs" />
+    <Compile Include="../MsgPack/Timestamp.Calculation.cs" Link="Timestamp.Calculation.cs" />
+    <Compile Include="../MsgPack/Timestamp.Comparison.cs" Link="Timestamp.Comparison.cs" />
+    <Compile Include="../MsgPack/Timestamp.Conversion.cs" Link="Timestamp.Conversion.cs" />
+    <Compile Include="../MsgPack/Timestamp.cs" Link="Timestamp.cs" />
+    <Compile Include="../MsgPack/Timestamp.ParseExact.cs" Link="Timestamp.ParseExact.cs" />
+    <Compile Include="../MsgPack/Timestamp.Properties.cs" Link="Timestamp.Properties.cs" />
+    <Compile Include="../MsgPack/Timestamp.ToString.cs" Link="Timestamp.ToString.cs" />
+    <Compile Include="../MsgPack/Timestamp.TryParseExact.cs" Link="Timestamp.TryParseExact.cs" />
+    <Compile Include="../MsgPack/TimestampParseResult.cs" Link="TimestampParseResult.cs" />
+    <Compile Include="../MsgPack/TimestampStringConverter.cs" Link="TimestampStringConverter.cs" />
+    <Compile Include="../MsgPack/TimestampStringConverter.Parse.cs" Link="TimestampStringConverter.Parse.cs" />
+    <Compile Include="../MsgPack/TimestampStringConverter.ToString.cs" Link="TimestampStringConverter.ToString.cs" />
+    <Compile Include="..\MsgPack\CollectionDebuggerProxy`1.cs" Link="CollectionDebuggerProxy`1.cs" />
+    <Compile Include="..\MsgPack\CollectionOperation.cs" Link="CollectionOperation.cs" />
+    <Compile Include="..\MsgPack\DictionaryDebuggerProxy`2.cs" Link="DictionaryDebuggerProxy`2.cs" />
+    <Compile Include="..\MsgPack\MessagePackConvert.cs" Link="MessagePackConvert.cs" />
+    <Compile Include="..\MsgPack\MessagePackObjectEqualityComparer.cs" Link="MessagePackObjectEqualityComparer.cs" />
+    <Compile Include="..\MsgPack\Serialization\DateTimeConversionMethod.cs" Link="Serialization\DateTimeConversionMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\EnumSerializationMethod.cs" Link="Serialization\EnumSerializationMethod.cs" />
     <Compile Include="..\MsgPack\Serialization\SerializationMethod.cs" Link="Serialization\SerializationMethod.cs" />
     <Compile Include="..\MsgPack\Serialization\SerializerCapabilities.cs" Link="Serialization\SerializerCapabilities.cs" />
+    <Compile Include="..\MsgPack\SetOperation.cs" Link="SetOperation.cs" />
   </ItemGroup>
 
   <ItemGroup>
@@ -38,7 +68,9 @@
     </None>
     <None Update="Serialization\SerializationOperationContext.tt">
       <LastGenOutput>SerializationOperationContext.cs</LastGenOutput>
+    <None Update="MessagePackObject.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>MessagePackObject.cs</LastGenOutput>
     </None>
   </ItemGroup>
 
@@ -82,6 +114,11 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>SerializationOperationContext.tt</DependentUpon>
     </Compile>
+    <Compile Update="MessagePackObject.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>MessagePackObject.tt</DependentUpon>
+    </Compile>
   </ItemGroup>
   
 </Project>
diff --git a/src/MsgPack/Binary.cs b/src/MsgPack/Binary.cs
index e86aeac43..ea427c6b2 100644
--- a/src/MsgPack/Binary.cs
+++ b/src/MsgPack/Binary.cs
@@ -1,127 +1,103 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
+using System.Runtime.CompilerServices;
 using System.Text;
+using MsgPack.Internal;
 
 namespace MsgPack
 {
 	/// <summary>
 	///		Defines binary related utilities.
 	/// </summary>
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	static class Binary
+	internal static class Binary
 	{
 		/// <summary>
 		///		Singleton empty <see cref="Byte"/>[].
 		/// </summary>
-		public static readonly byte[] Empty = new byte[ 0 ];
+		public static readonly byte[] Empty = new byte[0];
 
-		public static string ToHexString( byte[] blob )
+		public static string ToHexString(ReadOnlySpan<byte> blob)
 		{
-			return ToHexString( blob, true );
+			return ToHexString(blob, true);
 		}
 
-		public static string ToHexString( byte[] blob, bool withPrefix )
+		public static string ToHexString(ReadOnlySpan<byte> blob, bool withPrefix)
 		{
-			if ( blob == null || blob.Length == 0 )
+			if (blob == null || blob.Length == 0)
 			{
 				return String.Empty;
 			}
 
-			var buffer = new StringBuilder( blob.Length * 2 + (withPrefix ? 2 : 0 ) );
-			ToHexStringCore( blob, buffer, withPrefix );
+			var buffer = new StringBuilder(blob.Length * 2 + (withPrefix ? 2 : 0));
+			ToHexStringCore(blob, buffer, withPrefix);
 			return buffer.ToString();
 		}
 
-		public static void ToHexString( byte[] blob, StringBuilder buffer )
+		public static void ToHexString(ReadOnlySpan<byte> blob, StringBuilder buffer)
 		{
-			if ( blob == null || blob.Length == 0 )
+			if (blob == null || blob.Length == 0)
 			{
 				return;
 			}
 
-			ToHexStringCore( blob, buffer, true );
+			ToHexStringCore(blob, buffer, true);
 		}
 
-		private static void ToHexStringCore( byte[] blob, StringBuilder buffer, bool withPrefix )
+		private static void ToHexStringCore(ReadOnlySpan<byte> blob, StringBuilder buffer, bool withPrefix)
 		{
-			if ( withPrefix )
+			if (withPrefix)
 			{
-				buffer.Append( "0x" );
+				buffer.Append("0x");
 			}
 
-			foreach ( var b in blob )
+			foreach (var b in blob)
 			{
-				buffer.Append( ToHexChar( b >> 4 ) );
-				buffer.Append( ToHexChar( b & 0xF ) );
+				buffer.Append(ToHexChar(b >> 4));
+				buffer.Append(ToHexChar(b & 0xF));
 			}
 		}
 
-		private static char ToHexChar( int b )
+		private static char ToHexChar(int b)
 		{
-			if ( b < 10 )
+			if (b < 10)
 			{
-				return unchecked( ( char )( '0' + b ) );
+				return unchecked((char)('0' + b));
 			}
 			else
 			{
-				return unchecked( ( char )( 'A' + ( b - 10 ) ) );
+				return unchecked((char)('A' + (b - 10)));
 			}
 		}
 
-		public static int ToBits( float value )
-		{
-			var bits = new Float32Bits( value );
-			var result = default( int );
+#if FEATURE_ADVANCED_BIT_CONVERTER
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static int ToBits(float value)
+			=> BitConverter.SingleToInt32Bits(value);
+#else
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static unsafe int ToBits(float value)
+			=> *((int*)&value);
+#endif
 
-			// Float32Bits usage is effectively pointer dereference operation rather than shifting operators, so we must consider endianness here.
-			if ( BitConverter.IsLittleEndian )
-			{
-				result = bits.Byte3 << 24;
-				result |= bits.Byte2 << 16;
-				result |= bits.Byte1 << 8;
-				result |= bits.Byte0;
-			}
-			else
-			{
-				result = bits.Byte0 << 24;
-				result |= bits.Byte1 << 16;
-				result |= bits.Byte2 << 8;
-				result |= bits.Byte3;
-			}
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static long ToBits(double value)
+			=> BitConverter.DoubleToInt64Bits(value);
 
-			return result;
-		}
+#if FEATURE_ADVANCED_BIT_CONVERTER
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static float FromBits(int value)
+			=> BitConverter.Int32BitsToSingle(value);
+#else
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static unsafe float FromBits(int value)
+			=> *((float*)&value);
+#endif
 
-		public static long ToBits( double value )
-		{
-			return BitConverter.DoubleToInt64Bits( value );
-		}
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static double FromBits(long value)
+			=> BitConverter.Int64BitsToDouble(value);
 	}
 }
diff --git a/src/MsgPack/CollectionDebuggerProxy`1.cs b/src/MsgPack/CollectionDebuggerProxy`1.cs
index 2986bd485..5ab0597b4 100644
--- a/src/MsgPack/CollectionDebuggerProxy`1.cs
+++ b/src/MsgPack/CollectionDebuggerProxy`1.cs
@@ -1,24 +1,7 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2012 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
-using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 
@@ -39,18 +22,18 @@ public CollectionDebuggerProxy(ICollection<T> target)
 			this._collection = target;
 		}
 
-		[DebuggerBrowsable( DebuggerBrowsableState.RootHidden )]
-		public T[] Items
+		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+		public T[]? Items
 		{
 			get
 			{
-				if ( this._collection == null )
+				if (this._collection == null)
 				{
 					return null;
 				}
 
-				var result = new T[ this._collection.Count ];
-				this._collection.CopyTo( result, 0 );
+				var result = new T[this._collection.Count];
+				this._collection.CopyTo(result, 0);
 				return result;
 			}
 		}
diff --git a/src/MsgPack/CollectionOperation.cs b/src/MsgPack/CollectionOperation.cs
index 4134032b1..eecc953f7 100644
--- a/src/MsgPack/CollectionOperation.cs
+++ b/src/MsgPack/CollectionOperation.cs
@@ -1,119 +1,79 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 using System.Linq;
 
 namespace MsgPack
 {
 	internal static class CollectionOperation
 	{
-		public static void CopyTo<T>( IEnumerable<T> source, int sourceCount, int index, T[] array, int arrayIndex, int count )
+		public static void CopyTo<T>(IEnumerable<T> source, int sourceCount, int index, T[] array, int arrayIndex, int count)
 		{
-			ValidateCopyToArguments( sourceCount, index, array, arrayIndex, count );
+			ValidateCopyToArguments(sourceCount, index, array, arrayIndex, count);
 
 			var i = 0;
-			foreach ( var item in source.Skip( index ).Take( count ) )
+			foreach (var item in source.Skip(index).Take(count))
 			{
-				array[ i + arrayIndex ] = item;
+				array[i + arrayIndex] = item;
 				i++;
 			}
 		}
 
-		public static void CopyTo<TSource, TDestination>( IEnumerable<TSource> source, int sourceCount, int index, TDestination[] array, int arrayIndex, int count, Func<TSource, TDestination> converter )
+		public static void CopyTo<TSource, TDestination>(IEnumerable<TSource> source, int sourceCount, int index, TDestination[] array, int arrayIndex, int count, Func<TSource, TDestination> converter)
 		{
-			ValidateCopyToArguments( sourceCount, index, array, arrayIndex, count );
-			Contract.Assert( converter != null, "converter != null" );
+			ValidateCopyToArguments(sourceCount, index, array, arrayIndex, count);
+			Debug.Assert(converter != null, "converter != null");
 
 			int i = 0;
-			foreach ( var item in source.Skip( index ).Take( count ) )
+			foreach (var item in source.Skip(index).Take(count))
 			{
-				array[ i + arrayIndex ] = converter( item );
+				array[i + arrayIndex] = converter(item);
 				i++;
 			}
 		}
 
 		// ReSharper disable UnusedParameter.Local
-		private static void ValidateCopyToArguments<T>( int sourceCount, int index, T[] array, int arrayIndex, int count )
+		private static void ValidateCopyToArguments<T>(int sourceCount, int index, T[] array, int arrayIndex, int count)
 		// ReSharper restore UnusedParameter.Local
 		{
-			if ( array == null )
-			{
-				throw new ArgumentNullException( "array" );
-			}
+			Ensure.NotNull(array);
+			Ensure.IsNotNegative(index);
 
-			if ( index < 0 )
-			{
-				throw new ArgumentOutOfRangeException( "index" );
-			}
-
-			if ( 0 < sourceCount && sourceCount <= index )
+			if (0 < sourceCount && sourceCount <= index)
 			{
 				throw new ArgumentException(
-					"index is too large to finish copying.",
+					"'index' is too large to finish copying.",
 					"index"
 				);
 			}
 
-			if ( arrayIndex < 0 )
-			{
-				throw new ArgumentOutOfRangeException( "arrayIndex" );
-			}
+			Ensure.IsNotNegative(arrayIndex);
 
-			if ( array.Length - arrayIndex < count )
+			if (array.Length - arrayIndex < count)
 			{
 				throw new ArgumentException(
-					"array is too small to finish copying.",
+					"'array' is too small to finish copying.",
 					"array"
 				);
 			}
 		}
 
-		public static void CopyTo<T>( IEnumerable<T> source, int sourceCount, Array array, int arrayIndex )
+		public static void CopyTo<T>(IEnumerable<T> source, int sourceCount, Array array, int arrayIndex)
 		{
-			if ( array == null )
-			{
-				throw new ArgumentNullException( "array" );
-			}
+			Ensure.NotNull(array);
 
-			if ( array.Rank != 1 || array.GetLowerBound( 0 ) != 0 )
+			if (array.Rank != 1 || array.GetLowerBound(0) != 0)
 			{
-				throw new ArgumentException( "array is not zero-based one dimensional array.", "array" );
+				throw new ArgumentException("array is not zero-based one dimensional array.", "array");
 			}
 
-			if ( arrayIndex < 0 )
-			{
-				throw new ArgumentOutOfRangeException( "arrayIndex" );
-			}
+			Ensure.IsNotNegative(arrayIndex);
 
-			if ( array.Length - arrayIndex < sourceCount )
+			if (array.Length - arrayIndex < sourceCount)
 			{
 				throw new ArgumentException(
 					"array is too small to finish copying.",
@@ -122,21 +82,21 @@ public static void CopyTo<T>( IEnumerable<T> source, int sourceCount, Array arra
 			}
 
 			var asVector = array as T[];
-			if ( asVector != null )
+			if (asVector != null)
 			{
-				CopyTo( source, sourceCount, 0, asVector, arrayIndex, asVector.Length );
+				CopyTo(source, sourceCount, 0, asVector, arrayIndex, asVector.Length);
 				return;
 			}
 
 			int i = 0;
-			foreach ( var item in source )
+			foreach (var item in source)
 			{
 				try
 				{
-					array.SetValue( item, i + arrayIndex );
+					array.SetValue(item, i + arrayIndex);
 					i++;
 				}
-				catch ( InvalidCastException )
+				catch (InvalidCastException)
 				{
 					throw new ArgumentException(
 						"The type of destination array is not compatible to the type of items in the collection.",
diff --git a/src/MsgPack/DictionaryDebuggerProxy`2.cs b/src/MsgPack/DictionaryDebuggerProxy`2.cs
index 4d1153d70..e0dd78752 100644
--- a/src/MsgPack/DictionaryDebuggerProxy`2.cs
+++ b/src/MsgPack/DictionaryDebuggerProxy`2.cs
@@ -1,24 +1,7 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2012 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
-using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 
@@ -27,31 +10,32 @@ namespace MsgPack
 	// Thanks to Mono implementation.
 
 	/// <summary>
-	///		Debugger type proxy for <see cref="IDictionary{TKey,TValue}"/>.
+	///		Debugger type proxy for <see cref="IDictionary{TKey, TValue}"/>.
 	/// </summary>
 	/// <typeparam name="TKey">The key type of the dictionary.</typeparam>
 	/// <typeparam name="TValue">The value type of the dictionary.</typeparam>
-	internal sealed class DictionaryDebuggerProxy<TKey,TValue>
+	internal sealed class DictionaryDebuggerProxy<TKey, TValue>
+		where TKey : notnull
 	{
-		private readonly IDictionary<TKey,TValue> _dictionary;
+		private readonly IDictionary<TKey, TValue> _dictionary;
 
-		public DictionaryDebuggerProxy( IDictionary<TKey, TValue> target )
+		public DictionaryDebuggerProxy(IDictionary<TKey, TValue> target)
 		{
 			this._dictionary = target;
 		}
 
-		[DebuggerBrowsable( DebuggerBrowsableState.RootHidden )]
-		public KeyValuePair<TKey,TValue>[] Items
+		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
+		public KeyValuePair<TKey, TValue>[]? Items
 		{
 			get
 			{
-				if ( this._dictionary == null )
+				if (this._dictionary == null)
 				{
 					return null;
 				}
 
-				var result = new KeyValuePair<TKey, TValue>[ this._dictionary.Count ];
-				this._dictionary.CopyTo( result, 0 );
+				var result = new KeyValuePair<TKey, TValue>[this._dictionary.Count];
+				this._dictionary.CopyTo(result, 0);
 				return result;
 			}
 		}
diff --git a/src/MsgPack/MessageNotSupportedException.cs b/src/MsgPack/MessageNotSupportedException.cs
index 5c3f5f567..f1d258ca2 100644
--- a/src/MsgPack/MessageNotSupportedException.cs
+++ b/src/MsgPack/MessageNotSupportedException.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 #if FEATURE_BINARY_SERIALIZATION
diff --git a/src/MsgPack/MessagePackConvert.cs b/src/MsgPack/MessagePackConvert.cs
index 0f8d546ca..f543c9d0e 100644
--- a/src/MsgPack/MessagePackConvert.cs
+++ b/src/MsgPack/MessagePackConvert.cs
@@ -1,34 +1,8 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
-using System.Text;
 
 namespace MsgPack
 {
@@ -37,64 +11,9 @@ namespace MsgPack
 	/// </summary>
 	public static class MessagePackConvert
 	{
-		private static readonly Encoding _utf8NonBomStrict = new UTF8Encoding( false, true );
-		private static readonly Encoding _utf8NonBom = new UTF8Encoding( false, false );
 		private const long _ticksToMilliseconds = 10000;
 
-		internal static Encoding Utf8NonBom
-		{
-			get { return _utf8NonBom; }
-		}
-
-		internal static Encoding Utf8NonBomStrict
-		{
-			get { return _utf8NonBomStrict; }
-		}
-
-		/// <summary>
-		///		Encode specified string by default encoding.
-		/// </summary>
-		/// <param name="value">String value.</param>
-		/// <returns>Encoded <paramref name="value"/>.</returns>
-		/// <exception cref="ArgumentNullException">
-		///		<paramref name="value"/> is null.
-		/// </exception>
-		public static byte[] EncodeString( string value )
-		{
-			if ( value == null )
-			{
-				throw new ArgumentNullException( "value" );
-			}
-
-			Contract.EndContractBlock();
-
-			return _utf8NonBom.GetBytes( value );
-		}
-
-		/// <summary>
-		///		Decode specified byte[] by default encoding.
-		/// </summary>
-		/// <param name="value">Byte[] value.</param>
-		/// <returns>Decoded <paramref name="value"/>.</returns>
-		/// <exception cref="ArgumentNullException">
-		///		<paramref name="value"/> is null.
-		/// </exception>
-		/// <exception cref="System.Text.DecoderFallbackException">
-		///		<paramref name="value"/> contains non-UTF-8 bits.
-		/// </exception>
-		public static string DecodeStringStrict( byte[] value )
-		{
-			if ( value == null )
-			{
-				throw new ArgumentNullException( "value" );
-			}
-
-			Contract.EndContractBlock();
-
-			return _utf8NonBomStrict.GetString( value, 0, value.Length );
-		}
-
-		private static readonly DateTime _unixEpocUtc = new DateTime( 1970, 1, 1, 0, 0, 0, DateTimeKind.Utc );
+		private static readonly DateTime _unixEpocUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
 		/// <summary>
 		///		Convert specified <see cref="Int64"/> to <see cref="DateTimeOffset"/>.
@@ -105,10 +24,7 @@ public static string DecodeStringStrict( byte[] value )
 		/// <returns>
 		///		<see cref="DateTimeOffset"/>. Offset of this value always 0.
 		/// </returns>
-		public static DateTimeOffset ToDateTimeOffset( long value )
-		{
-			return _unixEpocUtc.AddTicks( value * _ticksToMilliseconds );
-		}
+		public static DateTimeOffset ToDateTimeOffset(long value) => _unixEpocUtc.AddTicks(value * _ticksToMilliseconds);
 
 		/// <summary>
 		///		Convert specified <see cref="Int64"/> to <see cref="DateTime"/>.
@@ -119,10 +35,7 @@ public static DateTimeOffset ToDateTimeOffset( long value )
 		/// <returns>
 		///		<see cref="DateTime"/>. This value is always UTC.
 		/// </returns>
-		public static DateTime ToDateTime( long value )
-		{
-			return _unixEpocUtc.AddTicks( value * _ticksToMilliseconds );
-		}
+		public static DateTime ToDateTime(long value) => _unixEpocUtc.AddTicks(value * _ticksToMilliseconds);
 
 		/// <summary>
 		///		Convert specified <see cref="DateTimeOffset"/> to <see cref="Int64"/> as MessagePack defacto-standard.
@@ -131,11 +44,9 @@ public static DateTime ToDateTime( long value )
 		/// <returns>
 		///		UTC epoc time from 1970/1/1 0:00:00, in milliseconds.
 		/// </returns>
-		public static long FromDateTimeOffset( DateTimeOffset value )
-		{
+		public static long FromDateTimeOffset(DateTimeOffset value)
 			// Note: microseconds and nanoseconds should always truncated, so deviding by integral is suitable.
-			return value.ToUniversalTime().Subtract( _unixEpocUtc ).Ticks / _ticksToMilliseconds;
-		}
+			=> value.ToUniversalTime().Subtract(_unixEpocUtc).Ticks / _ticksToMilliseconds;
 
 		/// <summary>
 		///		Convert specified <see cref="DateTime"/> to <see cref="Int64"/> as MessagePack defacto-standard.
@@ -144,10 +55,8 @@ public static long FromDateTimeOffset( DateTimeOffset value )
 		/// <returns>
 		///		UTC epoc time from 1970/1/1 0:00:00, in milliseconds.
 		/// </returns>
-		public static long FromDateTime( DateTime value )
-		{
+		public static long FromDateTime(DateTime value)
 			// Note: microseconds and nanoseconds should always truncated, so deviding by integral is suitable.
-			return value.ToUniversalTime().Subtract( _unixEpocUtc ).Ticks / _ticksToMilliseconds;
-		}
+			=> value.ToUniversalTime().Subtract(_unixEpocUtc).Ticks / _ticksToMilliseconds;
 	}
 }
diff --git a/src/MsgPack/MessagePackExtendedTypeObject.cs b/src/MsgPack/MessagePackExtendedTypeObject.cs
index dc96efbcf..cdc452830 100644
--- a/src/MsgPack/MessagePackExtendedTypeObject.cs
+++ b/src/MsgPack/MessagePackExtendedTypeObject.cs
@@ -1,26 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Text;
@@ -30,23 +10,16 @@ namespace MsgPack
 	/// <summary>
 	///		Represents Message Pack extended type object.
 	/// </summary>
+	[Obsolete("Use ExtensionTypeObject instead.")]
 	public struct MessagePackExtendedTypeObject : IEquatable<MessagePackExtendedTypeObject>
 	{
-		/// <summary>
-		///		A type code of this object.
-		/// </summary>
-		private readonly byte _typeCode;
-
 		/// <summary>
 		///		Gets a type code of this object.
 		/// </summary>
 		/// <value>
 		///		A type code. Note that values over <see cref="SByte.MaxValue"/> are reserved for MsgPack spec itself.
 		/// </value>
-		public byte TypeCode
-		{
-			get { return this._typeCode; }
-		}
+		public byte TypeCode { get; }
 
 		/// <summary>
 		///		A binary value portion of this object.
@@ -59,15 +32,7 @@ public byte TypeCode
 		/// <value>
 		///		A binary value portion of this object. This value will not be null.
 		/// </value>
-#if UNITY && DEBUG
-		public
-#else
-		internal
-#endif
-		byte[] Body
-		{
-			get { return this._body ?? Binary.Empty; }
-		}
+		internal byte[] Body => this._body ?? Binary.Empty;
 
 		/// <summary>
 		///		Gets a copy of the binary value portion of this object.
@@ -76,9 +41,7 @@ byte[] Body
 		///		A copy of the binary value portion of this object. This value will not be null.
 		/// </value>
 		public byte[] GetBody()
-		{
-			return this._body == null ? Binary.Empty : this._body.Clone() as byte[];
-		}
+			=> this._body == null ? Binary.Empty : (this._body.Clone() as byte[])!;
 
 		/// <summary>
 		///		Gets a value indicating whether this instance is valid.
@@ -86,25 +49,20 @@ public byte[] GetBody()
 		/// <value>
 		///   <c>true</c> if this instance is valid; otherwise, <c>false</c>.
 		/// </value>
-		public bool IsValid
-		{
-			get { return this._body != null; }
-		}
-
+		public bool IsValid => this._body != null;
 
 		// For unpacking
-		private MessagePackExtendedTypeObject( byte[] body, byte unpackedTypeCode )
+		private MessagePackExtendedTypeObject(byte[] body, byte unpackedTypeCode)
 		{
-			if ( body == null )
+			if (body == null)
 			{
-				throw new ArgumentNullException( "body" );
+				throw new ArgumentNullException("body");
 			}
 
-			this._typeCode = unpackedTypeCode;
+			this.TypeCode = unpackedTypeCode;
 			this._body = body;
 		}
 
-
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackExtendedTypeObject"/> struct.
 		/// </summary>
@@ -114,21 +72,21 @@ private MessagePackExtendedTypeObject( byte[] body, byte unpackedTypeCode )
 		///		The <paramref name="typeCode"/> is over 127. Higher values are reserved for MessagePack format specification.
 		/// </exception>
 		/// <exception cref="System.ArgumentNullException">The <paramref name="body"/> is <c>null</c>.</exception>
-		public MessagePackExtendedTypeObject( byte typeCode, byte[] body )
+		public MessagePackExtendedTypeObject(byte typeCode, byte[] body)
 		{
-			if ( typeCode > 0x7F )
+			if (typeCode > 0x7F)
 			{
 				throw new ArgumentException(
 					"A typeCode must be less than 128 because higher values are reserved for MessagePack format specification.",
-					"typeCode" );
+					"typeCode");
 			}
 
-			if ( body == null )
+			if (body == null)
 			{
-				throw new ArgumentNullException( "body" );
+				throw new ArgumentNullException("body");
 			}
 
-			this._typeCode = typeCode;
+			this.TypeCode = typeCode;
 			this._body = body;
 		}
 
@@ -141,9 +99,9 @@ public MessagePackExtendedTypeObject( byte typeCode, byte[] body )
 		/// <remarks>
 		///		This method allows reserved type code. It means that this method does not throw exception when the <paramref name="typeCode"/> is reserved value (greater then 0x7F).
 		/// </remarks>
-		public static MessagePackExtendedTypeObject Unpack( byte typeCode, byte[] body )
+		public static MessagePackExtendedTypeObject Unpack(byte typeCode, byte[] body)
 		{
-			return new MessagePackExtendedTypeObject( body, typeCode );
+			return new MessagePackExtendedTypeObject(body, typeCode);
 		}
 
 		/// <summary>
@@ -154,47 +112,41 @@ public static MessagePackExtendedTypeObject Unpack( byte typeCode, byte[] body )
 		/// </returns>
 		public override string ToString()
 		{
-			if ( this._body == null )
+			if (this._body == null)
 			{
 				return String.Empty;
 			}
 
-			var buffer = new StringBuilder( 7 + this._body.Length * 2 );
-			this.ToString( buffer, false );
+			var buffer = new StringBuilder(7 + this._body.Length * 2);
+			this.ToString(buffer, false);
 			return buffer.ToString();
 		}
 
-#if UNITY && DEBUG
-		public
-#else
-		internal
-#endif
-		void ToString( StringBuilder buffer, bool isJson )
+		internal void ToString(StringBuilder buffer, bool isJson)
 		{
-			if ( isJson )
+			if (isJson)
 			{
-				if ( this._body == null )
+				if (this._body == null)
 				{
 					// Assume that JSON is used when a collection is stringified, so empty string should break entire JSON.
-					buffer.Append( "null" );
+					buffer.Append("null");
 					return;
 				}
 
-				buffer.Append( "{\"TypeCode\":" ).Append( this._typeCode ).Append( ", \"Body\":\"" );
-				Binary.ToHexString( this._body, buffer );
-				buffer.Append( "\"}" );
+				buffer.Append("{\"TypeCode\":").Append(this.TypeCode).Append(", \"Body\":\"");
+				Binary.ToHexString(this._body, buffer);
+				buffer.Append("\"}");
 			}
 			else
 			{
-				if ( this._body == null )
+				if (this._body == null)
 				{
 					return;
 				}
 
-				buffer.Append( "[" ).Append( this._typeCode ).Append( "]" );
-				Binary.ToHexString( this._body, buffer );
+				buffer.Append("[").Append(this.TypeCode).Append("]");
+				Binary.ToHexString(this._body, buffer);
 			}
-
 		}
 
 		/// <summary>
@@ -205,24 +157,24 @@ void ToString( StringBuilder buffer, bool isJson )
 		/// </returns>
 		public override int GetHashCode()
 		{
-			if ( this._body == null )
+			if (this._body == null)
 			{
 				return 0;
 			}
 
 			unchecked
 			{
-				int hashCode = this._typeCode << 24;
+				int hashCode = this.TypeCode << 24;
 				hashCode ^= this._body.Length;
-				int hashCodeTargetLength = Math.Min( this._body.Length / 4, 8 );
-				for ( int i = 0; i < hashCodeTargetLength; i++ )
+				int hashCodeTargetLength = Math.Min(this._body.Length / 4, 8);
+				for (int i = 0; i < hashCodeTargetLength; i++)
 				{
-					uint temp = this._body[ i ];
-					temp |= ( uint )( this._body[ i + 1 ] << 8 );
-					temp |= ( uint )( this._body[ i + 2 ] << 16 );
-					temp |= ( uint )( this._body[ i + 3 ] << 24 );
+					uint temp = this._body[i];
+					temp |= (uint)(this._body[i + 1] << 8);
+					temp |= (uint)(this._body[i + 2] << 16);
+					temp |= (uint)(this._body[i + 3] << 24);
 
-					hashCode ^= ( int )temp;
+					hashCode ^= (int)temp;
 				}
 
 				return hashCode;
@@ -236,14 +188,14 @@ public override int GetHashCode()
 		/// <returns>
 		///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
 		/// </returns>
-		public override bool Equals( object obj )
+		public override bool Equals(object? obj)
 		{
-			if ( !( obj is MessagePackExtendedTypeObject ) )
+			if (!(obj is MessagePackExtendedTypeObject other))
 			{
 				return false;
 			}
 
-			return this.Equals( ( MessagePackExtendedTypeObject )obj );
+			return this.Equals(other);
 		}
 
 		/// <summary>
@@ -253,26 +205,26 @@ public override bool Equals( object obj )
 		/// <returns>
 		///   <c>true</c> if the specified <see cref="MessagePackExtendedTypeObject" /> is equal to this instance; otherwise, <c>false</c>.
 		/// </returns>
-		public bool Equals( MessagePackExtendedTypeObject other )
+		public bool Equals(MessagePackExtendedTypeObject other)
 		{
-			if ( this._typeCode != other._typeCode )
+			if (this.TypeCode != other.TypeCode)
 			{
 				return false;
 			}
 
-			if ( ReferenceEquals( this._body, other._body ) )
+			if (ReferenceEquals(this._body, other._body))
 			{
 				return true;
 			}
 
-			if ( this._body.Length != other._body.Length )
+			if (this._body.Length != other._body.Length)
 			{
 				return false;
 			}
 
-			for ( int i = 0; i < this._body.Length; i++ )
+			for (int i = 0; i < this._body.Length; i++)
 			{
-				if ( this._body[ i ] != other._body[ i ] )
+				if (this._body[i] != other._body[i])
 				{
 					return false;
 				}
@@ -289,9 +241,9 @@ public bool Equals( MessagePackExtendedTypeObject other )
 		/// <returns>
 		///   <c>true</c> if the specified <see cref="MessagePackExtendedTypeObject" />s are equal; otherwise, <c>false</c>.
 		/// </returns>
-		public static bool operator ==( MessagePackExtendedTypeObject left, MessagePackExtendedTypeObject right )
+		public static bool operator ==(MessagePackExtendedTypeObject left, MessagePackExtendedTypeObject right)
 		{
-			return left.Equals( right );
+			return left.Equals(right);
 		}
 
 		/// <summary>
@@ -302,9 +254,9 @@ public bool Equals( MessagePackExtendedTypeObject other )
 		/// <returns>
 		///   <c>true</c> if the specified <see cref="MessagePackExtendedTypeObject" />s are not equal; otherwise, <c>false</c>.
 		/// </returns>
-		public static bool operator !=( MessagePackExtendedTypeObject left, MessagePackExtendedTypeObject right )
+		public static bool operator !=(MessagePackExtendedTypeObject left, MessagePackExtendedTypeObject right)
 		{
-			return !left.Equals( right );
+			return !left.Equals(right);
 		}
 	}
 }
diff --git a/src/MsgPack/MessagePackObject.Utilities.cs b/src/MsgPack/MessagePackObject.Utilities.cs
index 6c9cf2354..8c5c48cb9 100644
--- a/src/MsgPack/MessagePackObject.Utilities.cs
+++ b/src/MsgPack/MessagePackObject.Utilities.cs
@@ -1,46 +1,17 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
+using System.Buffers;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // CORE_CLR || !UNITY || NETSTANDARD1_1
 using System.Globalization;
 using System.Linq;
-#if NETFX_CORE
-using System.Reflection;
-#endif
-using System.Runtime.Serialization;
 using System.Text;
-#if FEATURE_TAP
-using System.Threading;
-using System.Threading.Tasks;
-#endif // FEATURE_TAP
+
+using MsgPack.Internal;
 
 namespace MsgPack
 {
@@ -48,35 +19,34 @@ namespace MsgPack
 #warning TODO: Enable in .NET Standard 2.0 in Changes.txt
 	[Serializable]
 #endif // FEATURE_BINARY_SERIALIZATION
-	partial struct MessagePackObject : IPackable
-#if FEATURE_TAP
-		, IAsyncPackable
-#endif // FEATURE_TAP
+	public partial struct MessagePackObject
 	{
-#region -- Type Code Constants --
-
-		private static readonly ValueTypeCode _sbyteTypeCode = new ValueTypeCode( typeof( sbyte ), MessagePackValueTypeCode.Int8 );
-		private static readonly ValueTypeCode _byteTypeCode = new ValueTypeCode( typeof( byte ), MessagePackValueTypeCode.UInt8 );
-		private static readonly ValueTypeCode _int16TypeCode = new ValueTypeCode( typeof( short ), MessagePackValueTypeCode.Int16 );
-		private static readonly ValueTypeCode _uint16TypeCode = new ValueTypeCode( typeof( ushort ), MessagePackValueTypeCode.UInt16 );
-		private static readonly ValueTypeCode _int32TypeCode = new ValueTypeCode( typeof( int ), MessagePackValueTypeCode.Int32 );
-		private static readonly ValueTypeCode _uint32TypeCode = new ValueTypeCode( typeof( uint ), MessagePackValueTypeCode.UInt32 );
-		private static readonly ValueTypeCode _int64TypeCode = new ValueTypeCode( typeof( long ), MessagePackValueTypeCode.Int64 );
-		private static readonly ValueTypeCode _uint64TypeCode = new ValueTypeCode( typeof( ulong ), MessagePackValueTypeCode.UInt64 );
-		private static readonly ValueTypeCode _singleTypeCode = new ValueTypeCode( typeof( float ), MessagePackValueTypeCode.Single );
-		private static readonly ValueTypeCode _doubleTypeCode = new ValueTypeCode( typeof( double ), MessagePackValueTypeCode.Double );
-		private static readonly ValueTypeCode _booleanTypeCode = new ValueTypeCode( typeof( bool ), MessagePackValueTypeCode.Boolean );
-
-#endregion -- Type Code Constants --
+		#region -- Type Code Constants --
+
+		private static readonly ValueTypeCode SByteTypeCode = new ValueTypeCode(typeof(sbyte), MessagePackValueTypeCode.Int8);
+		private static readonly ValueTypeCode ByteTypeCode = new ValueTypeCode(typeof(byte), MessagePackValueTypeCode.UInt8);
+		private static readonly ValueTypeCode Int16TypeCode = new ValueTypeCode(typeof(short), MessagePackValueTypeCode.Int16);
+		private static readonly ValueTypeCode UInt16TypeCode = new ValueTypeCode(typeof(ushort), MessagePackValueTypeCode.UInt16);
+		private static readonly ValueTypeCode Int32TypeCode = new ValueTypeCode(typeof(int), MessagePackValueTypeCode.Int32);
+		private static readonly ValueTypeCode UInt32TypeCode = new ValueTypeCode(typeof(uint), MessagePackValueTypeCode.UInt32);
+		private static readonly ValueTypeCode Int64TypeCode = new ValueTypeCode(typeof(long), MessagePackValueTypeCode.Int64);
+		private static readonly ValueTypeCode UInt64TypeCode = new ValueTypeCode(typeof(ulong), MessagePackValueTypeCode.UInt64);
+		private static readonly ValueTypeCode SingleTypeCode = new ValueTypeCode(typeof(float), MessagePackValueTypeCode.Single);
+		private static readonly ValueTypeCode DoubleTypeCode = new ValueTypeCode(typeof(double), MessagePackValueTypeCode.Double);
+		private static readonly ValueTypeCode BooleanTypeCode = new ValueTypeCode(typeof(bool), MessagePackValueTypeCode.Boolean);
+
+		#endregion -- Type Code Constants --
 
 		/// <summary>
 		///		Instance represents nil. This is equal to default value.
 		/// </summary>
-		public static readonly MessagePackObject Nil = default ( MessagePackObject );
+		public static readonly MessagePackObject Nil = default(MessagePackObject);
+
+		#region -- Type Code Fields & Properties --
 
-#region -- Type Code Fields & Properties --
+		private readonly object? _handleOrTypeCode;
 
-		private object _handleOrTypeCode;
+		internal object? HandleOrTypeCode => this._handleOrTypeCode;
 
 		/// <summary>
 		///		Get whether this instance represents nil.
@@ -87,11 +57,11 @@ public bool IsNil
 			get { return this._handleOrTypeCode == null; }
 		}
 
-		private ulong _value;
+		private readonly ulong _value;
 
-#endregion -- Type Code Fields & Properties --
+		#endregion -- Type Code Fields & Properties --
 
-#region -- Constructors --
+		#region -- Constructors --
 
 		/// <summary>
 		///		Initializes a new instance wraps <see cref="IList&lt;MessagePackObject&gt;"/>.
@@ -99,8 +69,8 @@ public bool IsNil
 		/// <param name="value">
 		///		The collection to be copied.
 		/// </param>
-		public MessagePackObject( IList<MessagePackObject> value )
-			: this( value, false ) { }
+		public MessagePackObject(IList<MessagePackObject> value)
+			: this(value, false) { }
 
 		/// <summary>
 		///		Initializes a new instance wraps <see cref="IList&lt;MessagePackObject&gt;"/>.
@@ -121,24 +91,79 @@ public MessagePackObject( IList<MessagePackObject> value )
 		///			because the modification to the underlying collection will be reflected to the read-only collection.
 		///		</note>
 		/// </remarks>
-		public MessagePackObject( IList<MessagePackObject> value, bool isImmutable )
+		public MessagePackObject(IList<MessagePackObject> value, bool isImmutable)
 		{
 			// trick: Avoid long boilerplate initialization. See "CLR via C#".
 			this = new MessagePackObject();
-			if ( isImmutable )
+			if (isImmutable)
 			{
 				this._handleOrTypeCode = value;
 			}
 			else
 			{
-				if ( value == null )
+				if (value == null)
 				{
 					this._handleOrTypeCode = null;
 				}
 				else
 				{
-					var copy = new MessagePackObject[ value.Count ];
-					value.CopyTo( copy, 0 );
+					var copy = new MessagePackObject[value.Count];
+					value.CopyTo(copy, 0);
+					this._handleOrTypeCode = copy;
+				}
+			}
+		}
+
+		/// <summary>
+		///		Initializes a new instance wraps <see cref="IReadOnlyList&lt;MessagePackObject&gt;"/>.
+		/// </summary>
+		/// <param name="value">
+		///		The collection to be copied.
+		/// </param>
+		public MessagePackObject(IReadOnlyList<MessagePackObject> value)
+			: this(value, false) { }
+
+		/// <summary>
+		///		Initializes a new instance wraps <see cref="IReadOnlyList&lt;MessagePackObject&gt;"/>.
+		/// </summary>
+		/// <param name="value">
+		///		The collection to be copied or used.
+		/// </param>
+		/// <param name="isImmutable">
+		///		<c>true</c> if the <paramref name="value"/> is immutable collection;
+		///		othereise, <c>false</c>.
+		/// </param>
+		/// <remarks>
+		///		When the collection is truely immutable or dedicated, you can specify <c>true</c> to the <paramref name="isImmutable"/>.
+		///		When <paramref name="isImmutable"/> is <c>true</c>, this constructor does not copy its contents,
+		///		or copies its contents otherwise.
+		///		<note>
+		///			Note that both of IReadOnlyList and <see cref="System.Collections.ObjectModel.ReadOnlyCollection{T}"/> is NOT immutable
+		///			because the modification to the underlying collection will be reflected to the read-only collection.
+		///		</note>
+		/// </remarks>
+		public MessagePackObject(IReadOnlyList<MessagePackObject> value, bool isImmutable)
+		{
+			// trick: Avoid long boilerplate initialization. See "CLR via C#".
+			this = new MessagePackObject();
+			if (isImmutable)
+			{
+				this._handleOrTypeCode = value;
+			}
+			else
+			{
+				if (value == null)
+				{
+					this._handleOrTypeCode = null;
+				}
+				else
+				{
+					var copy = new MessagePackObject[value.Count];
+					for (var i = 0; i < copy.Length; i++)
+					{
+						copy[i] = value[i];
+					}
+
 					this._handleOrTypeCode = copy;
 				}
 			}
@@ -150,8 +175,8 @@ public MessagePackObject( IList<MessagePackObject> value, bool isImmutable )
 		/// <param name="value">
 		///		The dictitonary to be copied.
 		/// </param>
-		public MessagePackObject( MessagePackObjectDictionary value )
-			: this( value, false ) { }
+		public MessagePackObject(MessagePackObjectDictionary value)
+			: this(value, false) { }
 
 		/// <summary>
 		///		Initializes a new instance wraps <see cref="MessagePackObjectDictionary"/>.
@@ -172,23 +197,23 @@ public MessagePackObject( MessagePackObjectDictionary value )
 		///			because the modification to the underlying collection will be reflected to the read-only collection.
 		///		</note>
 		/// </remarks>
-		public MessagePackObject( MessagePackObjectDictionary value, bool isImmutable )
+		public MessagePackObject(MessagePackObjectDictionary value, bool isImmutable)
 		{
 			// trick: Avoid long boilerplate initialization. See "CLR via C#".
 			this = new MessagePackObject();
-			if ( isImmutable )
+			if (isImmutable)
 			{
 				this._handleOrTypeCode = value;
 			}
 			else
 			{
-				if ( value == null )
+				if (value == null)
 				{
 					this._handleOrTypeCode = null;
 				}
 				else
 				{
-					this._handleOrTypeCode = new MessagePackObjectDictionary( value );
+					this._handleOrTypeCode = new MessagePackObjectDictionary(value);
 				}
 			}
 		}
@@ -202,16 +227,16 @@ public MessagePackObject( MessagePackObjectDictionary value, bool isImmutable )
 #else
 		internal
 #endif
-		MessagePackObject( MessagePackString messagePackString )
+		MessagePackObject(MessagePackString messagePackString)
 		{
 			// trick: Avoid long boilerplate initialization. See "CLR via C#".
 			this = new MessagePackObject();
 			this._handleOrTypeCode = messagePackString;
 		}
 
-#endregion -- Constructors --
+		#endregion -- Constructors --
 
-#region -- Structure Methods --
+		#region -- Structure Methods --
 
 		/// <summary>
 		///		Compare two instances are equal.
@@ -221,24 +246,23 @@ public MessagePackObject( MessagePackObjectDictionary value, bool isImmutable )
 		///		If <paramref name="obj"/> is <see cref="MessagePackObject"/> and its value is equal to this instance, then true.
 		///		Otherwise false.
 		/// </returns>
-		public override bool Equals( Object obj )
+		public override bool Equals(object? obj)
 		{
-			MessagePackObjectDictionary asDictionary;
-			if ( ReferenceEquals( obj, null ) )
+			if (ReferenceEquals(obj, null))
 			{
 				return this.IsNil;
 			}
-			else if ( ( asDictionary = obj as MessagePackObjectDictionary ) != null )
+			else if (obj is MessagePackObjectDictionary asDictionary)
 			{
-				return this.Equals( new MessagePackObject( asDictionary ) );
+				return this.Equals(new MessagePackObject(asDictionary));
 			}
-			else if ( !( obj is MessagePackObject ) )
+			else if (obj is MessagePackObject other)
 			{
-				return false;
+				return this.Equals(other);
 			}
 			else
 			{
-				return this.Equals( ( MessagePackObject )obj );
+				return false;
 			}
 		}
 
@@ -249,198 +273,182 @@ public override bool Equals( Object obj )
 		/// <returns>
 		///		Whether value of <paramref name="other"/> is equal to this instance or not.
 		/// </returns>
-		public bool Equals( MessagePackObject other )
+		public bool Equals(MessagePackObject other)
 		{
-			if ( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
 				return other._handleOrTypeCode == null;
 			}
-			else if ( other._handleOrTypeCode == null )
+			else if (other._handleOrTypeCode == null)
 			{
 				return false;
 			}
 
-			var valueTypeCode = this._handleOrTypeCode as ValueTypeCode;
-			if ( valueTypeCode != null )
+			if (this._handleOrTypeCode is ValueTypeCode valueTypeCode)
 			{
-				var otherValuetypeCode = other._handleOrTypeCode as ValueTypeCode;
-				if ( otherValuetypeCode == null )
+				if (!(this._handleOrTypeCode is ValueTypeCode otherValuetypeCode))
 				{
 					return false;
 				}
 
-				return this.EqualsWhenValueType( other, valueTypeCode, otherValuetypeCode );
+				return this.EqualsWhenValueType(other, valueTypeCode, otherValuetypeCode);
+			}
+
+			if (this._handleOrTypeCode is MessagePackString asMps)
+			{
+				return asMps.Equals(other._handleOrTypeCode as MessagePackString);
 			}
 
+			if (this._handleOrTypeCode is IList<MessagePackObject> asList)
 			{
-				var asMps = this._handleOrTypeCode as MessagePackString;
-				if ( asMps != null )
+				if (!(other._handleOrTypeCode is IList<MessagePackObject> otherAsList))
 				{
-					return asMps.Equals( other._handleOrTypeCode as MessagePackString );
+					return false;
 				}
+
+				return asList.SequenceEqual(otherAsList, MessagePackObjectEqualityComparer.Instance);
 			}
 
+			if (this._handleOrTypeCode is IReadOnlyList<MessagePackObject> asReadOnlyList)
 			{
-				var asArray = this._handleOrTypeCode as IList<MessagePackObject>;
-				if ( asArray != null )
+				if (!(other._handleOrTypeCode is IReadOnlyList<MessagePackObject> otherAsReadOnlyList))
 				{
-					var otherAsArray = other._handleOrTypeCode as IList<MessagePackObject>;
-					if ( otherAsArray == null )
-					{
-						return false;
-					}
-
-					return asArray.SequenceEqual( otherAsArray, MessagePackObjectEqualityComparer.Instance );
+					return false;
 				}
+
+				return asReadOnlyList.SequenceEqual(otherAsReadOnlyList, MessagePackObjectEqualityComparer.Instance);
 			}
 
+			if (this._handleOrTypeCode is MessagePackObjectDictionary asMap)
 			{
-				var asMap = this._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject>;
-				if ( asMap != null )
+				if (!(this._handleOrTypeCode is MessagePackObjectDictionary otherAsMap))
 				{
-					var otherAsMap = other._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject>;
-					if ( otherAsMap == null )
-					{
-						return false;
-					}
+					return false;
+				}
+
+				if (asMap.Count != otherAsMap.Count)
+				{
+					return false;
+				}
 
-					if ( asMap.Count != otherAsMap.Count )
+				foreach (var kv in asMap)
+				{
+					if (!otherAsMap.TryGetValue(kv.Key, out var value))
 					{
 						return false;
 					}
 
-					foreach ( var kv in asMap )
+					if (kv.Value != value)
 					{
-						MessagePackObject value;
-						if ( !otherAsMap.TryGetValue( kv.Key, out value ) )
-						{
-							return false;
-						}
-
-						if ( kv.Value != value )
-						{
-							return false;
-						}
+						return false;
 					}
-
-					return true;
 				}
+
+				return true;
 			}
 
+			if (this._handleOrTypeCode is ReadOnlySequence<byte> asExtensionTypeObjectBody)
 			{
-				// ReSharper disable HeuristicUnreachableCode
-				// ReSharper disable once ExpressionIsAlwaysNull
-				var asExtendedTypeObjectBody = this._handleOrTypeCode as byte[];
-				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-				if ( asExtendedTypeObjectBody != null )
+				if (!(other._handleOrTypeCode is ReadOnlySequence<byte> otherAsExtensionTypeObjectBody))
 				{
-					var otherAsExtendedTypeObjectBody = other._handleOrTypeCode as byte[];
-					if ( otherAsExtendedTypeObjectBody == null )
-					{
-						return false;
-					}
-
-					unchecked
-					{
-						return MessagePackExtendedTypeObject.Unpack( ( byte )this._value, asExtendedTypeObjectBody ) ==
-							   MessagePackExtendedTypeObject.Unpack( ( byte )other._value, otherAsExtendedTypeObjectBody );
-					}
+					return false;
 				}
-				// ReSharper restore HeuristicUnreachableCode
+
+				return
+					new ExtensionTypeObject(new ExtensionType(unchecked((long)this._value)), asExtensionTypeObjectBody) ==
+						new ExtensionTypeObject(new ExtensionType(unchecked((long)this._value)), otherAsExtensionTypeObjectBody);
 			}
 
-#if DEBUG
-			Contract.Assert( false, String.Format( "Unknown handle type this:'{0}'(value: '{1}'), other:'{2}'(value: '{3}')", this._handleOrTypeCode.GetType(), this._handleOrTypeCode, other._handleOrTypeCode.GetType(), other._handleOrTypeCode ) );
-#endif // DEBUG
-			return this._handleOrTypeCode.Equals( other._handleOrTypeCode );
+			Debug.Fail($"Unknown handle type this:'{this._handleOrTypeCode.GetType()}'(value: '{this._value}'), other:'{other._handleOrTypeCode.GetType()}'(value: '{other._value}')");
+			return this._handleOrTypeCode.Equals(other._handleOrTypeCode);
 		}
 
 		private bool EqualsWhenValueType(
 			MessagePackObject other,
 			ValueTypeCode valueTypeCode,
-			ValueTypeCode otherValuetypeCode )
+			ValueTypeCode otherValuetypeCode)
 		{
-			if ( valueTypeCode.TypeCode == MessagePackValueTypeCode.Boolean )
+			if (valueTypeCode.TypeCode == MessagePackValueTypeCode.Boolean)
 			{
-				if ( otherValuetypeCode.TypeCode != MessagePackValueTypeCode.Boolean )
+				if (otherValuetypeCode.TypeCode != MessagePackValueTypeCode.Boolean)
 				{
 					return false;
 				}
 
-				return ( bool ) this == ( bool ) other;
+				return (bool)this == (bool)other;
 			}
-			else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Boolean )
+			else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Boolean)
 			{
 				return false;
 			}
 
-			if ( valueTypeCode.IsInteger )
+			if (valueTypeCode.IsInteger)
 			{
-				if ( otherValuetypeCode.IsInteger )
+				if (otherValuetypeCode.IsInteger)
 				{
-					return IntegerIntegerEquals( this._value, valueTypeCode, other._value, otherValuetypeCode );
+					return IntegerIntegerEquals(this._value, valueTypeCode, other._value, otherValuetypeCode);
 				}
-				else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Single )
+				else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Single)
 				{
-					return IntegerSingleEquals( this, other );
+					return IntegerSingleEquals(this, other);
 				}
-				else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Double )
+				else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Double)
 				{
-					return IntegerDoubleEquals( this, other );
+					return IntegerDoubleEquals(this, other);
 				}
 			}
-			else if ( valueTypeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (valueTypeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				if ( otherValuetypeCode.IsInteger )
+				if (otherValuetypeCode.IsInteger)
 				{
-					return IntegerDoubleEquals( other, this );
+					return IntegerDoubleEquals(other, this);
 				}
-				else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Single )
+				else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Single)
 				{
 					// ReSharper disable once CompareOfFloatsByEqualityOperator
-					return ( double ) this == ( float ) other;
+					return (double)this == (float)other;
 				}
-				else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Double )
+				else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Double)
 				{
 					// ReSharper disable once CompareOfFloatsByEqualityOperator
 					// Cannot compare _value because there might be not normalized.
-					return ( double )this == ( double )other;
+					return (double)this == (double)other;
 				}
 			}
-			else if ( valueTypeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (valueTypeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				if ( otherValuetypeCode.IsInteger )
+				if (otherValuetypeCode.IsInteger)
 				{
-					return IntegerSingleEquals( other, this );
+					return IntegerSingleEquals(other, this);
 				}
-				else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Single )
+				else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Single)
 				{
 					// ReSharper disable once CompareOfFloatsByEqualityOperator
 					// Cannot compare _value because there might be not normalized.
-					return ( float ) this == ( float ) other;
+					return (float)this == (float)other;
 				}
-				else if ( otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Double )
+				else if (otherValuetypeCode.TypeCode == MessagePackValueTypeCode.Double)
 				{
 					// ReSharper disable once CompareOfFloatsByEqualityOperator
-					return ( float )this == ( double )other;
+					return (float)this == (double)other;
 				}
 			}
 
 			return false;
 		}
 
-		private static bool IntegerIntegerEquals( ulong left, ValueTypeCode leftTypeCode, ulong right, ValueTypeCode rightTypeCode )
+		private static bool IntegerIntegerEquals(ulong left, ValueTypeCode leftTypeCode, ulong right, ValueTypeCode rightTypeCode)
 		{
-			if ( leftTypeCode.IsSigned )
+			if (leftTypeCode.IsSigned)
 			{
-				if ( rightTypeCode.IsSigned )
+				if (rightTypeCode.IsSigned)
 				{
 					return left == right;
 				}
 				else
 				{
-					var leftAsInt64 = unchecked( ( long )left );
-					if ( leftAsInt64 < 0L )
+					var leftAsInt64 = unchecked((long)left);
+					if (leftAsInt64 < 0L)
 					{
 						return false;
 					}
@@ -450,10 +458,10 @@ private static bool IntegerIntegerEquals( ulong left, ValueTypeCode leftTypeCode
 			}
 			else
 			{
-				if ( rightTypeCode.IsSigned )
+				if (rightTypeCode.IsSigned)
 				{
-					var rightAsInt64 = unchecked( ( long )right );
-					if ( rightAsInt64 < 0L )
+					var rightAsInt64 = unchecked((long)right);
+					if (rightAsInt64 < 0L)
 					{
 						return false;
 					}
@@ -467,37 +475,35 @@ private static bool IntegerIntegerEquals( ulong left, ValueTypeCode leftTypeCode
 			}
 		}
 
-		private static bool IntegerSingleEquals( MessagePackObject integer, MessagePackObject real )
+		private static bool IntegerSingleEquals(MessagePackObject integer, MessagePackObject real)
 		{
-#if DEBUG
-			Contract.Assert( integer._handleOrTypeCode is ValueTypeCode, "integer._handleOrTypeCode is ValueTypeCode" );
-#endif // DEBUG
-			if ( ( integer._handleOrTypeCode as ValueTypeCode ).IsSigned )
+			Debug.Assert(integer._handleOrTypeCode is ValueTypeCode, "integer._handleOrTypeCode is ValueTypeCode");
+
+			if (((integer._handleOrTypeCode as ValueTypeCode)?.IsSigned).GetValueOrDefault())
 			{
 				// ReSharper disable once CompareOfFloatsByEqualityOperator
-				return unchecked( ( long )integer._value ) == ( float )real;
+				return unchecked((long)integer._value) == (float)real;
 			}
 			else
 			{
 				// ReSharper disable once CompareOfFloatsByEqualityOperator
-				return integer._value == ( float )real;
+				return integer._value == (float)real;
 			}
 		}
 
-		private static bool IntegerDoubleEquals( MessagePackObject integer, MessagePackObject real )
+		private static bool IntegerDoubleEquals(MessagePackObject integer, MessagePackObject real)
 		{
-#if DEBUG
-			Contract.Assert( integer._handleOrTypeCode is ValueTypeCode, "integer._handleOrTypeCode is ValueTypeCode" );
-#endif // DEBUG
-			if ( ( integer._handleOrTypeCode as ValueTypeCode ).IsSigned )
+			Debug.Assert(integer._handleOrTypeCode is ValueTypeCode, "integer._handleOrTypeCode is ValueTypeCode");
+
+			if (((integer._handleOrTypeCode as ValueTypeCode)?.IsSigned).GetValueOrDefault())
 			{
 				// ReSharper disable once CompareOfFloatsByEqualityOperator
-				return unchecked( ( long )integer._value ) == ( double )real;
+				return unchecked((long)integer._value) == (double)real;
 			}
 			else
 			{
 				// ReSharper disable once CompareOfFloatsByEqualityOperator
-				return integer._value == ( double )real;
+				return integer._value == (double)real;
 			}
 		}
 
@@ -508,65 +514,39 @@ private static bool IntegerDoubleEquals( MessagePackObject integer, MessagePackO
 		public override int GetHashCode()
 		{
 			// ReSharper disable NonReadonlyFieldInGetHashCode
-			if ( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
 				return 0;
 			}
 
-			if ( this._handleOrTypeCode is ValueTypeCode )
+			if (this._handleOrTypeCode is ValueTypeCode)
 			{
 				return this._value.GetHashCode();
 			}
 
+			if (this._handleOrTypeCode is MessagePackString asMps)
 			{
-				var asMps = this._handleOrTypeCode as MessagePackString;
-				if ( asMps != null )
-				{
-					return asMps.GetHashCode();
-				}
+				return asMps.GetHashCode();
 			}
 
+			if (this._handleOrTypeCode is IEnumerable<MessagePackObject> asList)
 			{
-				var asArray = this._handleOrTypeCode as IList<MessagePackObject>;
-				if ( asArray != null )
-				{
-					// TODO: big array support...
-					return asArray.Aggregate( 0, ( hash, item ) => hash ^ item.GetHashCode() );
-				}
+				return asList.Aggregate(0, (hash, item) => hash ^ item.GetHashCode());
 			}
 
+			if (this._handleOrTypeCode is MessagePackObjectDictionary asMap)
 			{
-				var asMap = this._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject>;
-				if ( asMap != null )
-				{
-					// TODO: big map support...
-					return asMap.Aggregate( 0, ( hash, item ) => hash ^ item.GetHashCode() );
-				}
+#warning TODO: item.GetHashCode() -> item.Key.GetHashCode() ^ item.Value.GetHashCode()
+				return asMap.Aggregate(0, (hash, item) => hash ^ item.GetHashCode());
 			}
 
+			if (this._handleOrTypeCode is ReadOnlySequence<byte> asExtensionTypeObjectBody)
 			{
-				// ReSharper disable HeuristicUnreachableCode
-				// ReSharper disable once ExpressionIsAlwaysNull
-				var asExtendedTypeObjectBody = this._handleOrTypeCode as byte[];
-				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-				if ( asExtendedTypeObjectBody != null )
-				{
-					unchecked
-					{
-						return MessagePackExtendedTypeObject.Unpack( ( byte )this._value, asExtendedTypeObjectBody ).GetHashCode();
-					}
-				}
-				// ReSharper restore HeuristicUnreachableCode
+				return new ExtensionTypeObject(new ExtensionType(unchecked((long)this._value)), asExtensionTypeObjectBody).GetHashCode();
 			}
 
-			{
-#if DEBUG
-				Contract.Assert( false, String.Format( "(this._handleOrTypeCode is string) but {0}", this._handleOrTypeCode.GetType() ) );
-#endif // DEBUG
-				// ReSharper disable once HeuristicUnreachableCode
-				return 0;
-			}
-			// ReSharper restore NonReadonlyFieldInGetHashCode
+			Debug.Fail($"Unexpected handle type: {this._handleOrTypeCode.GetType()}");
+			return 0;
 		}
 
 		/// <summary>
@@ -583,60 +563,66 @@ public override int GetHashCode()
 		/// </remarks>
 		public override string ToString()
 		{
-			var buffer = new StringBuilder();
-			this.ToString( buffer, false );
-			return buffer.ToString();
+			var buffer = StringBuilderCache.Acquire();
+			try
+			{
+				this.ToString(buffer, false);
+				return buffer.ToString();
+			}
+			finally
+			{
+				StringBuilderCache.Release(buffer);
+			}
 		}
 
-		private void ToString( StringBuilder buffer, bool isJson )
+		private void ToString(StringBuilder buffer, bool isJson)
 		{
-			if ( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
-				if ( isJson )
+				if (isJson)
 				{
-					buffer.Append( "null" );
+					buffer.Append("null");
 				}
 
 				return;
 			}
 
-			ValueTypeCode valueTypeCode;
-			if ( ( valueTypeCode = this._handleOrTypeCode as ValueTypeCode ) != null )
+			if (this._handleOrTypeCode is ValueTypeCode valueTypeCode)
 			{
-				switch ( valueTypeCode.TypeCode )
+				switch (valueTypeCode.TypeCode)
 				{
 					case MessagePackValueTypeCode.Boolean:
 					{
-						if ( isJson )
+						if (isJson)
 						{
-							buffer.Append( this.AsBoolean() ? "true" : "false" );
+							buffer.Append(this.AsBoolean() ? "true" : "false");
 						}
 						else
 						{
-							buffer.Append( this.AsBoolean() );
+							buffer.Append(this.AsBoolean());
 						}
 
 						break;
 					}
 					case MessagePackValueTypeCode.Double:
 					{
-						buffer.Append( this.AsDouble().ToString( CultureInfo.InvariantCulture ) );
+						buffer.Append(this.AsDouble().ToString(CultureInfo.InvariantCulture));
 						break;
 					}
 					case MessagePackValueTypeCode.Single:
 					{
-						buffer.Append( this.AsSingle().ToString( CultureInfo.InvariantCulture ) );
+						buffer.Append(this.AsSingle().ToString(CultureInfo.InvariantCulture));
 						break;
 					}
 					default:
 					{
-						if ( valueTypeCode.IsSigned )
+						if (valueTypeCode.IsSigned)
 						{
-							buffer.Append( unchecked( ( long )( this._value ) ).ToString( CultureInfo.InvariantCulture ) );
+							buffer.Append(unchecked((long)(this._value)).ToString(CultureInfo.InvariantCulture));
 						}
 						else
 						{
-							buffer.Append( this._value.ToString( CultureInfo.InvariantCulture ) );
+							buffer.Append(this._value.ToString(CultureInfo.InvariantCulture));
 						}
 
 						break;
@@ -646,166 +632,151 @@ private void ToString( StringBuilder buffer, bool isJson )
 				return;
 			}
 
+			if (this._handleOrTypeCode is IEnumerable<MessagePackObject> asList)
 			{
-				var asArray = this._handleOrTypeCode as IList<MessagePackObject>;
-				if ( asArray != null )
+				// TODO: big array support...
+				buffer.Append('[');
+				var isFirst = true;
+				foreach (var item in asList)
 				{
-					// TODO: big array support...
-					buffer.Append( '[' );
-					if ( asArray.Count > 0 )
+					if (isFirst)
 					{
-						for ( int i = 0; i < asArray.Count; i++ )
-						{
-							if ( i > 0 )
-							{
-								buffer.Append( ',' );
-							}
-
-							buffer.Append( ' ' );
-							asArray[ i ].ToString( buffer, true );
-						}
-
-						buffer.Append( ' ' );
+						isFirst = false;
+					}
+					else
+					{
+						buffer.Append(',');
 					}
 
-					buffer.Append( ']' );
-					return;
+					buffer.Append(' ');
+					item.ToString(buffer, isJson);
 				}
+
+				if (!isFirst)
+				{
+					buffer.Append(' ');
+				}
+
+				buffer.Append(']');
+				return;
 			}
 
+			if (this._handleOrTypeCode is MessagePackObjectDictionary asMap)
 			{
-				var asMap = this._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject>;
-				if ( asMap != null )
+				buffer.Append('{');
+				if (asMap.Count > 0)
 				{
-					// TODO: big map support...
-					buffer.Append( '{' );
-					if ( asMap.Count > 0 )
+					bool isFirst = true;
+					foreach (var entry in asMap)
 					{
-						bool isFirst = true;
-						foreach ( var entry in asMap )
+						if (isFirst)
 						{
-							if ( isFirst )
-							{
-								isFirst = false;
-							}
-							else
-							{
-								buffer.Append( ',' );
-							}
-
-							buffer.Append( ' ' );
-							entry.Key.ToString( buffer, true );
-							buffer.Append( ' ' ).Append( ':' ).Append( ' ' );
-							entry.Value.ToString( buffer, true );
+							isFirst = false;
+						}
+						else
+						{
+							buffer.Append(',');
 						}
 
-						buffer.Append( ' ' );
+						buffer.Append(' ');
+						entry.Key.ToString(buffer, isJson);
+						buffer.Append(" : ");
+						entry.Value.ToString(buffer, isJson);
 					}
 
-					buffer.Append( '}' );
-					return;
+					buffer.Append(' ');
 				}
+
+				buffer.Append('}');
+				return;
 			}
 
+			if (this._handleOrTypeCode is MessagePackString asBinary)
 			{
-				var asBinary = this._handleOrTypeCode as MessagePackString;
-				if ( asBinary != null )
-				{
-					ToStringBinary( buffer, isJson, asBinary );
-					return;
-				}
+				ToStringBinary(buffer, isJson, asBinary);
+				return;
 			}
 
+			if (this._handleOrTypeCode is ReadOnlySequence<byte> asExtensionTypeObjectBody)
 			{
-				// ReSharper disable HeuristicUnreachableCode
-				// ReSharper disable once ExpressionIsAlwaysNull
-				var asExtendedTypeObjectBody = this._handleOrTypeCode as byte[];
-				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-				if ( asExtendedTypeObjectBody != null )
-				{
-					MessagePackExtendedTypeObject.Unpack( ( byte )this._value, asExtendedTypeObjectBody ).ToString( buffer, isJson );
-					return;
-				}
-				// ReSharper restore HeuristicUnreachableCode
+				new ExtensionTypeObject(new ExtensionType(unchecked((long)this._value)), asExtensionTypeObjectBody).ToString(buffer, isJson);
+				return;
 			}
 
 			// may be string
-#if DEBUG
-			Contract.Assert( false, String.Format( "(this._handleOrTypeCode is string) but {0}", this._handleOrTypeCode.GetType() ) );
-#endif // DEBUG
+			Debug.Fail($"Unexpected handle type: {this._handleOrTypeCode.GetType()}");
 			// ReSharper disable HeuristicUnreachableCode
-			if ( isJson )
+			if (isJson)
 			{
-				buffer.Append( '"' ).Append( this._handleOrTypeCode ).Append( '"' );
+				buffer.Append('"').Append(this._handleOrTypeCode).Append('"');
 			}
 			else
 			{
-				buffer.Append( this._handleOrTypeCode );
+				buffer.Append(this._handleOrTypeCode);
 			}
 			// ReSharper restore HeuristicUnreachableCode
 		}
 
-		private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePackString asBinary )
+		private static void ToStringBinary(StringBuilder buffer, bool isJson, MessagePackString asBinary)
 		{
-			// TODO: big array support...
 			var asString = asBinary.TryGetString();
-			if ( asString != null )
+			if (asString != null)
 			{
-				if ( isJson )
+				if (isJson)
 				{
-					buffer.Append( '"' );
-					foreach ( var c in asString )
+					buffer.Append('"');
+					foreach (var c in asString)
 					{
-						switch ( c )
+						switch (c)
 						{
 							case '"':
 							{
-								buffer.Append( '\\' ).Append( '"' );
+								buffer.Append('\\').Append('"');
 								break;
 							}
 							case '\\':
 							{
-								buffer.Append( '\\' ).Append( '\\' );
+								buffer.Append('\\').Append('\\');
 								break;
 							}
 							case '/':
 							{
-								buffer.Append( '\\' ).Append( '/' );
+								buffer.Append('\\').Append('/');
 								break;
 							}
 							case '\b':
 							{
-								buffer.Append( '\\' ).Append( 'b' );
+								buffer.Append('\\').Append('b');
 								break;
 							}
 							case '\f':
 							{
-								buffer.Append( '\\' ).Append( 'f' );
+								buffer.Append('\\').Append('f');
 								break;
 							}
 							case '\n':
 							{
-								buffer.Append( '\\' ).Append( 'n' );
+								buffer.Append('\\').Append('n');
 								break;
 							}
 							case '\r':
 							{
-								buffer.Append( '\\' ).Append( 'r' );
+								buffer.Append('\\').Append('r');
 								break;
 							}
 							case '\t':
 							{
-								buffer.Append( '\\' ).Append( 't' );
+								buffer.Append('\\').Append('t');
 								break;
 							}
 							case ' ':
 							{
-								buffer.Append( ' ' );
+								buffer.Append(' ');
 								break;
 							}
 							default:
 							{
-								switch ( CharUnicodeInfo.GetUnicodeCategory( c ) )
+								switch (CharUnicodeInfo.GetUnicodeCategory(c))
 								{
 									case UnicodeCategory.Control:
 									case UnicodeCategory.OtherNotAssigned:
@@ -816,12 +787,12 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 									case UnicodeCategory.PrivateUse:
 									case UnicodeCategory.Surrogate:
 									{
-										buffer.Append( '\\' ).Append( 'u' ).Append( ( ( ushort ) c ).ToString( "X", CultureInfo.InvariantCulture ) );
+										buffer.Append('\\').Append('u').Append(((ushort)c).ToString("X", CultureInfo.InvariantCulture));
 										break;
 									}
 									default:
 									{
-										buffer.Append( c );
+										buffer.Append(c);
 										break;
 									}
 								}
@@ -831,45 +802,55 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 						}
 					}
 
-					buffer.Append( '"' );
+					buffer.Append('"');
 				}
 				else
 				{
-					buffer.Append( asString );
+					buffer.Append(asString);
 				}
 
 				return;
 			}
 
-			var asBlob = asBinary.UnsafeGetBuffer();
-			if ( asBlob != null )
+			var asBlob = asBinary.UnsafeGetMemory();
+			if (isJson)
 			{
-				if ( isJson )
-				{
-					buffer.Append( '"' );
-					Binary.ToHexString( asBlob, buffer );
-					buffer.Append( '"' );
-				}
-				else
+				buffer.Append('"');
+
+				const int byteSpanLength = 96;
+				const int charSpanLength = byteSpanLength / 3 * 4;
+				var byteSpan = asBlob.Span;
+				Span<char> charSpan = stackalloc char[charSpanLength];
+				while (!byteSpan.IsEmpty)
 				{
-					Binary.ToHexString( asBlob, buffer );
+					var byteLength = (int)Math.Min(byteSpan.Length, byteSpanLength);
+					Convert.TryToBase64Chars(byteSpan.Slice(0, byteLength), charSpan, out var charsWritten, Base64FormattingOptions.None);
+					buffer.Append(charSpan.Slice(0, charsWritten));
+					byteSpan = byteSpan.Slice(byteLength);
 				}
+
+				buffer.Append('"');
+			}
+			else
+			{
+				buffer.Append("0x");
+				Binary.ToHexString(asBlob.Span, buffer);
 			}
 		}
 
-#endregion -- Structure Methods --
+		#endregion -- Structure Methods --
 
-#region -- Type Of Methods --
+		#region -- Type Of Methods --
 
 		/// <summary>
 		///		Determine whether the underlying value of this instance is specified type or not.
 		/// </summary>
 		/// <typeparam name="T">Target type.</typeparam>
 		/// <returns>If the underlying value of this instance is <typeparamref name="T"/> then true, otherwise false.</returns>
-		[SuppressMessage( "Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "There are no meaningful parameter." )]
+		[SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "There are no meaningful parameter.")]
 		public bool? IsTypeOf<T>()
 		{
-			return this.IsTypeOf( typeof( T ) );
+			return this.IsTypeOf(typeof(T));
 		}
 
 		/// <summary>
@@ -878,65 +859,56 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 		/// <param name="type">Target type.</param>
 		/// <returns>If the underlying value of this instance is <paramref name="type"/> then true, otherwise false.</returns>
 		/// <exception cref="ArgumentNullException"><paramref name="type"/> is null.</exception>
-		[SuppressMessage( "Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Switch" )]
-		public bool? IsTypeOf( Type type )
+		[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Switch")]
+		public bool? IsTypeOf(Type type)
 		{
-			if ( type == null )
-			{
-				throw new ArgumentNullException( "type" );
-			}
-
-			Contract.EndContractBlock();
+			type = Ensure.NotNull(type);
 
-			if ( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
-#if NETFX_CORE
-				return ( type.GetTypeInfo().IsValueType && Nullable.GetUnderlyingType( type ) == null ) ? false : default( bool? );
-#else
-				return ( type.GetIsValueType() && Nullable.GetUnderlyingType( type ) == null ) ? false : default( bool? );
-#endif
+				return (type.IsValueType && Nullable.GetUnderlyingType(type) == null) ? false : default(bool?);
 			}
 
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if ( typeCode == null )
+			if (typeCode == null)
 			{
-				if ( type == typeof( MessagePackExtendedTypeObject ) )
+				if (type == typeof(ExtensionTypeObject))
 				{
-					return this._handleOrTypeCode is byte[];
+					return this._handleOrTypeCode is ReadOnlySequence<byte>;
 				}
 
-				if ( type == typeof( string ) || type == typeof( IList<char> ) || type == typeof( IEnumerable<char> ) )
+				if (type == typeof(string) || type == typeof(IList<char>) || type == typeof(IEnumerable<char>))
 				{
 					var asMessagePackString = this._handleOrTypeCode as MessagePackString;
-					return asMessagePackString != null && asMessagePackString.GetUnderlyingType() == typeof( string );
+					return asMessagePackString != null && asMessagePackString.GetUnderlyingType() == typeof(string);
 				}
 
-				if ( type == typeof( byte[] ) || type == typeof( IList<byte> ) || type == typeof( IEnumerable<byte> ) )
+				if (type == typeof(byte[]) || type == typeof(IList<byte>) || type == typeof(IEnumerable<byte>))
 				{
 					return this._handleOrTypeCode is MessagePackString;
 				}
 
 				// Can IEnumerable<byte>
-				if ( typeof( IEnumerable<MessagePackObject> ).IsAssignableFrom( type )
-					&& this._handleOrTypeCode is MessagePackString )
+				if (typeof(IEnumerable<MessagePackObject>).IsAssignableFrom(type)
+					&& this._handleOrTypeCode is MessagePackString)
 				{
 					// Raw is NOT array.
 					return false;
 				}
 
-				return type.IsAssignableFrom( this._handleOrTypeCode.GetType() );
+				return type.IsAssignableFrom(this._handleOrTypeCode.GetType());
 			}
 
 			// Lifting support.
-#if ( NETSTANDARD1_1 || NETSTANDARD1_3 )
+#if (NETSTANDARD1_1 || NETSTANDARD1_3)
 			switch ( NetStandardCompatibility.GetTypeCode( type ) )
 #else
-			switch ( Type.GetTypeCode( type ) )
+			switch (Type.GetTypeCode(type))
 #endif // NETSTANDARD1_1 || NETSTANDARD1_3
 			{
 				case TypeCode.SByte:
 				{
-					return typeCode.IsInteger && ( this._value < 0x80 || ( 0xFFFFFFFFFFFFFF80 <= this._value && typeCode.IsSigned ) );
+					return typeCode.IsInteger && (this._value < 0x80 || (0xFFFFFFFFFFFFFF80 <= this._value && typeCode.IsSigned));
 				}
 				case TypeCode.Byte:
 				{
@@ -944,7 +916,7 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 				}
 				case TypeCode.Int16:
 				{
-					return typeCode.IsInteger && ( this._value < 0x8000 || ( 0xFFFFFFFFFFFF8000 <= this._value && typeCode.IsSigned ) );
+					return typeCode.IsInteger && (this._value < 0x8000 || (0xFFFFFFFFFFFF8000 <= this._value && typeCode.IsSigned));
 				}
 				case TypeCode.UInt16:
 				{
@@ -952,7 +924,7 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 				}
 				case TypeCode.Int32:
 				{
-					return typeCode.IsInteger && ( this._value < 0x80000000 || ( 0xFFFFFFFF80000000 <= this._value && typeCode.IsSigned ) );
+					return typeCode.IsInteger && (this._value < 0x80000000 || (0xFFFFFFFF80000000 <= this._value && typeCode.IsSigned));
 				}
 				case TypeCode.UInt32:
 				{
@@ -960,17 +932,17 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 				}
 				case TypeCode.Int64:
 				{
-					return typeCode.IsInteger && ( this._value < 0x8000000000000000L || typeCode.IsSigned );
+					return typeCode.IsInteger && (this._value < 0x8000000000000000L || typeCode.IsSigned);
 				}
 				case TypeCode.UInt64:
 				{
-					return typeCode.IsInteger && ( this._value < 0x8000000000000000L || !typeCode.IsSigned );
+					return typeCode.IsInteger && (this._value < 0x8000000000000000L || !typeCode.IsSigned);
 				}
 				case TypeCode.Double:
 				{
 					return
-						typeCode.Type == typeof( float )
-						|| typeCode.Type == typeof( double );
+						typeCode.Type == typeof(float)
+						|| typeCode.Type == typeof(double);
 				}
 			}
 
@@ -983,7 +955,7 @@ private static void ToStringBinary( StringBuilder buffer, bool isJson, MessagePa
 		/// <value>This instance wraps raw binary (or string) then true.</value>
 		public bool IsRaw
 		{
-			get { return !this.IsNil && ( this._handleOrTypeCode is MessagePackString ); }
+			get { return !this.IsNil && (this._handleOrTypeCode is MessagePackString); }
 		}
 
 		/// <summary>
@@ -1025,31 +997,25 @@ public bool IsMap
 		/// <summary>
 		///		Get underlying type of this instance.
 		/// </summary>
-		/// <returns>Underlying <see cref="Type"/>.</returns>
-		public Type UnderlyingType
+		/// <returns>Underlying <see cref="Type"/>. <c>null</c> for <see cref="Nil"/>.</returns>
+		public Type? UnderlyingType
 		{
 			get
 			{
-				if ( this._handleOrTypeCode == null )
+				if (this._handleOrTypeCode == null)
 				{
 					return null;
 				}
 
-				var typeCode = this._handleOrTypeCode as ValueTypeCode;
-				if ( typeCode == null )
+				if (!(this._handleOrTypeCode is ValueTypeCode typeCode))
 				{
-					var asMps = this._handleOrTypeCode as MessagePackString;
-					if ( asMps != null )
+					if (this._handleOrTypeCode is MessagePackString asMps)
 					{
 						return asMps.GetUnderlyingType();
 					}
-					else if ( this._handleOrTypeCode is byte[] )
+					else if (this._handleOrTypeCode is ReadOnlySequence<byte>)
 					{
-						// It should be MPETO
-#if DEBUG
-						Contract.Assert( ( this._value & 0xFFFFFFFFFFFFFF00 ) == 0, "( " + this._value.ToString( "X16" ) + " & 0xFFFFFFFFFFFFFF00 ) != 0" );
-#endif // DEBUG
-						return typeof( MessagePackExtendedTypeObject );
+						return typeof(ExtensionTypeObject);
 					}
 					else
 					{
@@ -1063,290 +1029,9 @@ public Type UnderlyingType
 			}
 		}
 
-#endregion -- Type Of Methods --
-
-		/// <summary>
-		///		Packs this instance itself using specified <see cref="Packer"/>.
-		/// </summary>
-		/// <param name="packer"><see cref="Packer"/>.</param>
-		/// <param name="options">Packing options. This value can be null.</param>
-		/// <exception cref="ArgumentNullException"><paramref name="packer"/> is null.</exception>
-		public void PackToMessage( Packer packer, PackingOptions options )
-		{
-			if ( packer == null )
-			{
-				throw new ArgumentNullException( "packer" );
-			}
-
-			Contract.EndContractBlock();
-
-			if ( this._handleOrTypeCode == null )
-			{
-				packer.PackNull();
-				return;
-			}
-
-			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if ( typeCode == null )
-			{
-				MessagePackString asString;
-				IList<MessagePackObject> asList;
-				IDictionary<MessagePackObject, MessagePackObject> asDictionary;
-				byte[] asExtendedTypeObjectBody;
-				if ( ( asString = this._handleOrTypeCode as MessagePackString ) != null )
-				{
-					if ( asString.GetUnderlyingType() == typeof( string ) || ( packer.CompatibilityOptions & PackerCompatibilityOptions.PackBinaryAsRaw ) != 0 )
-					{
-						packer.PackRaw( asString.GetBytes() );
-					}
-					else
-					{
-						packer.PackBinary( asString.GetBytes() );
-					}
-				}
-				else if ( ( asList = this._handleOrTypeCode as IList<MessagePackObject> ) != null )
-				{
-					packer.PackArrayHeader( asList.Count );
-					foreach ( var item in asList )
-					{
-						item.PackToMessage( packer, options );
-					}
-				}
-				else if ( ( asDictionary = this._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject> ) != null )
-				{
-					packer.PackMapHeader( asDictionary.Count );
-					foreach ( var item in asDictionary )
-					{
-						item.Key.PackToMessage( packer, options );
-						item.Value.PackToMessage( packer, options );
-					}
-				}
-				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-				// ReSharper disable HeuristicUnreachableCode
-				else if ( ( asExtendedTypeObjectBody = this._handleOrTypeCode as byte[] ) != null )
-				{
-					packer.PackExtendedTypeValue( unchecked( ( byte )this._value ), asExtendedTypeObjectBody );
-				}
-				// ReSharper restore HeuristicUnreachableCode
-				else
-				{
-					throw new SerializationException( "Failed to pack this object." );
-				}
-
-				return;
-			}
-
-			switch ( typeCode.TypeCode )
-			{
-				case MessagePackValueTypeCode.Single:
-				{
-					packer.Pack( ( float )this );
-					return;
-				}
-				case MessagePackValueTypeCode.Double:
-				{
-					packer.Pack( ( double )this );
-					return;
-				}
-				case MessagePackValueTypeCode.Int8:
-				{
-					packer.Pack( ( sbyte )this );
-					return;
-				}
-				case MessagePackValueTypeCode.Int16:
-				{
-					packer.Pack( ( short )this );
-					return;
-				}
-				case MessagePackValueTypeCode.Int32:
-				{
-					packer.Pack( ( int )this );
-					return;
-				}
-				case MessagePackValueTypeCode.Int64:
-				{
-					packer.Pack( ( long )this );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt8:
-				{
-					packer.Pack( ( byte )this );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt16:
-				{
-					packer.Pack( ( ushort )this );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt32:
-				{
-					packer.Pack( ( uint )this );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt64:
-				{
-					packer.Pack( this._value );
-					return;
-				}
-				case MessagePackValueTypeCode.Boolean:
-				{
-					packer.Pack( this._value != 0 );
-					return;
-				}
-				default:
-				{
-					throw new SerializationException( "Failed to pack this object." );
-				}
-			}
-		}
-
-#if FEATURE_TAP
-
-		/// <summary>
-		///		Packs this object contents to the specified <see cref="Packer"/> asynchronously.
-		/// </summary>
-		/// <param name="packer"><see cref="Packer" />.</param>
-		/// <param name="options">Packing options. This value can be null.</param>
-		/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>
-		/// <returns>
-		///		A <see cref="Task" /> that represents the asynchronous operation.
-		/// </returns>
-		/// <exception cref="System.ArgumentNullException">packer</exception>
-		/// <exception cref="System.Runtime.Serialization.SerializationException">
-		///		Failed to serialize this object.
-		/// </exception>
-		public async Task PackToMessageAsync( Packer packer, PackingOptions options, CancellationToken cancellationToken )
-		{
-			if ( packer == null )
-			{
-				throw new ArgumentNullException( "packer" );
-			}
-
-			Contract.EndContractBlock();
+		#endregion -- Type Of Methods --
 
-			if ( this._handleOrTypeCode == null )
-			{
-				await packer.PackNullAsync( cancellationToken ).ConfigureAwait( false );
-				return;
-			}
-
-			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if ( typeCode == null )
-			{
-				MessagePackString asString;
-				IList<MessagePackObject> asList;
-				IDictionary<MessagePackObject, MessagePackObject> asDictionary;
-				byte[] asExtendedTypeObjectBody;
-				if ( ( asString = this._handleOrTypeCode as MessagePackString ) != null )
-				{
-					if ( asString.GetUnderlyingType() == typeof( string ) || ( packer.CompatibilityOptions & PackerCompatibilityOptions.PackBinaryAsRaw ) != 0 )
-					{
-						await packer.PackRawAsync( asString.GetBytes(), cancellationToken ).ConfigureAwait( false );
-					}
-					else
-					{
-						await packer.PackBinaryAsync( asString.GetBytes(), cancellationToken ).ConfigureAwait( false );
-					}
-				}
-				else if ( ( asList = this._handleOrTypeCode as IList<MessagePackObject> ) != null )
-				{
-					await packer.PackArrayHeaderAsync( asList.Count, cancellationToken ).ConfigureAwait( false );
-					foreach ( var item in asList )
-					{
-						await item.PackToMessageAsync( packer, options, cancellationToken ).ConfigureAwait( false );
-					}
-				}
-				else if ( ( asDictionary = this._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject> ) != null )
-				{
-					await packer.PackMapHeaderAsync( asDictionary.Count, cancellationToken ).ConfigureAwait( false );
-					foreach ( var item in asDictionary )
-					{
-						await item.Key.PackToMessageAsync( packer, options, cancellationToken ).ConfigureAwait( false );
-						await item.Value.PackToMessageAsync( packer, options, cancellationToken ).ConfigureAwait( false );
-					}
-				}
-				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-				// ReSharper disable HeuristicUnreachableCode
-				else if ( ( asExtendedTypeObjectBody = this._handleOrTypeCode as byte[] ) != null )
-				{
-					await packer.PackExtendedTypeValueAsync( unchecked( ( byte )this._value ), asExtendedTypeObjectBody, cancellationToken ).ConfigureAwait( false );
-				}
-				// ReSharper restore HeuristicUnreachableCode
-				else
-				{
-					throw new SerializationException( "Failed to pack this object." );
-				}
-
-				return;
-			}
-
-			switch ( typeCode.TypeCode )
-			{
-				case MessagePackValueTypeCode.Single:
-				{
-					await packer.PackAsync( ( float )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.Double:
-				{
-					await packer.PackAsync( ( double )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.Int8:
-				{
-					await packer.PackAsync( ( sbyte )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.Int16:
-				{
-					await packer.PackAsync( ( short )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.Int32:
-				{
-					await packer.PackAsync( ( int )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.Int64:
-				{
-					await packer.PackAsync( ( long )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt8:
-				{
-					await packer.PackAsync( ( byte )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt16:
-				{
-					await packer.PackAsync( ( ushort )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt32:
-				{
-					await packer.PackAsync( ( uint )this, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.UInt64:
-				{
-					await packer.PackAsync( this._value, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				case MessagePackValueTypeCode.Boolean:
-				{
-					await packer.PackAsync( this._value != 0, cancellationToken ).ConfigureAwait( false );
-					return;
-				}
-				default:
-				{
-					throw new SerializationException( "Failed to pack this object." );
-				}
-			}
-		}
-
-#endif // FEATURE_TAP
-
-#region -- Primitive Type Conversion Methods --
+		#region -- Primitive Type Conversion Methods --
 
 		/// <summary>
 		///		Gets the underlying value as string encoded with specified <see cref="Encoding"/>.
@@ -1355,50 +1040,41 @@ public async Task PackToMessageAsync( Packer packer, PackingOptions options, Can
 		///		The string.
 		///		Note that some <see cref="Encoding"/> returns <c>null</c> if the binary is not valid encoded string.
 		///	</returns>
-		public string AsString( Encoding encoding )
+		public string? AsString(Encoding encoding)
 		{
-			if ( encoding == null )
-			{
-				throw new ArgumentNullException( "encoding" );
-			}
-
-			Contract.EndContractBlock();
+			encoding = Ensure.NotNull(encoding);
 
-			if ( this.IsNil )
+			if (this.IsNil)
 			{
 				return null;
 			}
 
-			VerifyUnderlyingRawType<string>( this, null );
+			VerifyUnderlyingRawType<string>(this, null);
 
 			try
 			{
 				var asMessagePackString = this._handleOrTypeCode as MessagePackString;
-#if DEBUG
-				Contract.Assert( asMessagePackString != null, "asMessagePackString != null" );
-#endif // DEBUG
+				Debug.Assert(asMessagePackString != null, "asMessagePackString != null");
 
-				if ( encoding is UTF8Encoding )
+				if (encoding is UTF8Encoding)
 				{
 					return asMessagePackString.GetString();
 				}
 
-				return encoding.GetString( asMessagePackString.UnsafeGetBuffer(), 0, asMessagePackString.UnsafeGetBuffer().Length );
+				return encoding.GetString(asMessagePackString.UnsafeGetMemory().Span);
 			}
-			catch ( ArgumentException ex )
+			catch (ArgumentException ex)
 			{
-				throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "Not '{0}' string.", encoding.WebName ), ex );
+				throw new InvalidOperationException($"Not a '{encoding.WebName}' string.", ex);
 			}
 		}
 
 		/// <summary>
-		///		Get underlying value as UTF8 string.
+		///		Get underlying value as UTF-8 string.
 		/// </summary>
-		/// <returns>Underlying raw binary.</returns>
-		public string AsStringUtf8()
-		{
-			return this.AsString( MessagePackConvert.Utf8NonBomStrict );
-		}
+		/// <returns>Underlying raw binary as <see cref="String"/> decoded with UTF-8 encoding. <c>null</c> for <see cref="Nil"/>.</returns>
+		public string? AsStringUtf8()
+			=> this.AsString(Utf8EncodingNonBomStrict.Instance);
 
 		/// <summary>
 		///		Get underlying value as UTF-16 string.
@@ -1407,85 +1083,83 @@ public string AsStringUtf8()
 		/// <remarks>
 		///		This method detects BOM. If BOM is not exist, them bytes should be Big-Endian UTF-16.
 		/// </remarks>
-		public string AsStringUtf16()
+		public string? AsStringUtf16()
 		{
-			VerifyUnderlyingRawType<string>( this, null );
-			Contract.EndContractBlock();
+			VerifyUnderlyingRawType<string>(this, null);
 
-			if ( this.IsNil )
+			if (this.IsNil)
 			{
 				return null;
 			}
 
 			try
 			{
-				MessagePackString asMessagePackString = this._handleOrTypeCode as MessagePackString;
-#if DEBUG
-				Contract.Assert( asMessagePackString != null, "asMessagePackString != null" );
-#endif // DEBUG
+				var asMessagePackString = this._handleOrTypeCode as MessagePackString;
+				Debug.Assert(asMessagePackString != null, "asMessagePackString != null");
 
-				if ( asMessagePackString.UnsafeGetString() != null )
+				if (asMessagePackString.UnsafeGetString() != null)
 				{
 					return asMessagePackString.UnsafeGetString();
 				}
 
-				byte[] asBytes = asMessagePackString.UnsafeGetBuffer();
+				var asBytes = asMessagePackString.UnsafeGetMemory();
 
-				if ( asBytes.Length == 0 )
+				if (asBytes.Length == 0)
 				{
 					return String.Empty;
 				}
 
-				if ( asBytes.Length % 2 != 0 )
+				if (asBytes.Length % 2 != 0)
 				{
-					throw new InvalidOperationException( "Not UTF-16 string." );
+					throw new InvalidOperationException("Not a UTF-16 string.");
 				}
 
-				if ( asBytes[ 0 ] == 0xff && asBytes[ 1 ] == 0xfe )
+				if (asBytes.Span[0] == 0xff && asBytes.Span[1] == 0xfe)
 				{
-					return Encoding.Unicode.GetString( asBytes, 2, asBytes.Length - 2 );
+					return Encoding.Unicode.GetString(asBytes.Span.Slice(2));
 				}
-				else if ( asBytes[ 0 ] == 0xfe && asBytes[ 1 ] == 0xff )
+				else if (asBytes.Span[0] == 0xfe && asBytes.Span[1] == 0xff)
 				{
-					return Encoding.BigEndianUnicode.GetString( asBytes, 2, asBytes.Length - 2 );
+					return Encoding.BigEndianUnicode.GetString(asBytes.Span.Slice(2));
 				}
 				else
 				{
-					return Encoding.BigEndianUnicode.GetString( asBytes, 0, asBytes.Length );
+					return Encoding.BigEndianUnicode.GetString(asBytes.Span);
 				}
 			}
-			catch ( ArgumentException ex )
+			catch (ArgumentException ex)
 			{
-				throw new InvalidOperationException( "Not UTF-16 string.", ex );
+				throw new InvalidOperationException("Not a UTF-16 string.", ex);
 			}
 		}
 
 		/// <summary>
 		///		Get underlying value as UTF-16 charcter array.
 		/// </summary>
-		/// <returns>Underlying string.</returns>
-		public char[] AsCharArray()
+		/// <returns>Underlying string. <c>null</c> for <see cref="Nil"/>.</returns>
+		public char[]? AsCharArray()
 		{
 			// TODO: More efficient
+#warning TODO: NRE
 			return this.AsString().ToCharArray();
 		}
 
-#endregion -- Primitive Type Conversion Methods --
+		#endregion -- Primitive Type Conversion Methods --
 
-#region -- Container Type Conversion Methods --
+		#region -- Container Type Conversion Methods --
 
 		/// <summary>
 		///		Get underlying value as <see cref="IEnumerable&lt;MessagePackObject&gt;"/>.
 		/// </summary>
-		/// <returns>Underlying <see cref="IEnumerable&lt;MessagePackObject&gt;"/>.</returns>
-		public IEnumerable<MessagePackObject> AsEnumerable()
+		/// <returns>Underlying <see cref="IEnumerable&lt;MessagePackObject&gt;"/>. <c>null</c> for <see cref="Nil"/>.</returns>
+		public IEnumerable<MessagePackObject>? AsEnumerable()
 		{
-			if ( this.IsNil )
+			if (this.IsNil)
 			{
 				return null;
 			}
 
-			VerifyUnderlyingType<IEnumerable<MessagePackObject>>( this, null );
+			VerifyUnderlyingType<IEnumerable<MessagePackObject>>(this, null);
 
 			return this._handleOrTypeCode as IEnumerable<MessagePackObject>;
 		}
@@ -1494,14 +1168,14 @@ public IEnumerable<MessagePackObject> AsEnumerable()
 		///		Get underlying value as <see cref="IList&lt;MessagePackObject&gt;"/>.
 		/// </summary>
 		/// <returns>Underlying <see cref="IList&lt;MessagePackObject&gt;"/>.</returns>
-		public IList<MessagePackObject> AsList()
+		public IList<MessagePackObject>? AsList()
 		{
-			if ( this.IsNil )
+			if (this.IsNil)
 			{
 				return null;
 			}
 
-			VerifyUnderlyingType<IList<MessagePackObject>>( this, null );
+			VerifyUnderlyingType<IList<MessagePackObject>>(this, null);
 
 			return this._handleOrTypeCode as IList<MessagePackObject>;
 		}
@@ -1510,34 +1184,37 @@ public IList<MessagePackObject> AsList()
 		///		Get underlying value as <see cref="MessagePackObjectDictionary"/>.
 		/// </summary>
 		/// <returns>Underlying <see cref="MessagePackObjectDictionary"/>.</returns>
-		public MessagePackObjectDictionary AsDictionary()
+		public MessagePackObjectDictionary? AsDictionary()
 		{
-			VerifyUnderlyingType<MessagePackObjectDictionary>( this, null );
+			if (this.IsNil)
+			{
+				return null;
+			}
+
+			VerifyUnderlyingType<MessagePackObjectDictionary>(this, null);
 
 			return this._handleOrTypeCode as MessagePackObjectDictionary;
 		}
 
-#endregion -- Container Type Conversion Methods --
+		#endregion -- Container Type Conversion Methods --
 
-#region -- Utility Methods --
+		#region -- Utility Methods --
 
-		private static void VerifyUnderlyingType<T>( MessagePackObject instance, string parameterName )
+		private static void VerifyUnderlyingType<T>(MessagePackObject instance, string? parameterName)
 		{
-#if DEBUG
-			Contract.Assert( typeof( T ) != typeof( MessagePackString ), "Should use VerifyUnderlyingRawType()" );
-#endif // DEBUG
+			Debug.Assert(typeof(T) != typeof(MessagePackString), "Should use VerifyUnderlyingRawType()");
 
-			if ( instance.IsNil )
+			if (instance.IsNil)
 			{
-				if ( !typeof( T ).GetIsValueType() || Nullable.GetUnderlyingType( typeof( T ) ) != null )
+				if (!typeof(T).IsValueType || Nullable.GetUnderlyingType(typeof(T)) != null)
 				{
 					return;
 				}
 
 				// TODO: localize
-				if ( parameterName != null )
+				if (parameterName != null)
 				{
-					throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, "Do not convert nil MessagePackObject to {0}.", typeof( T ) ), parameterName );
+					throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "Do not convert nil MessagePackObject to {0}.", typeof(T)), parameterName);
 				}
 				else
 				{
@@ -1545,55 +1222,55 @@ private static void VerifyUnderlyingType<T>( MessagePackObject instance, string
 				}
 			}
 
-			if ( !instance.IsTypeOf<T>().GetValueOrDefault() )
+			if (!instance.IsTypeOf<T>().GetValueOrDefault())
 			{
-				if ( parameterName != null )
+				if (parameterName != null)
 				{
-					throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, "Do not convert {0} MessagePackObject to {1}.", instance.UnderlyingType, typeof( T ) ), parameterName );
+					throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "Do not convert {0} MessagePackObject to {1}.", instance.UnderlyingType, typeof(T)), parameterName);
 				}
 				else
 				{
-					ThrowInvalidTypeAs<T>( instance );
+					ThrowInvalidTypeAs<T>(instance);
 				}
 			}
 		}
 
-		private static void VerifyUnderlyingRawType<T>( MessagePackObject instance, string parameterName )
+		private static void VerifyUnderlyingRawType<T>(MessagePackObject instance, string? parameterName)
 		{
-			if ( instance._handleOrTypeCode == null || instance._handleOrTypeCode is MessagePackString )
+			if (instance._handleOrTypeCode == null || instance._handleOrTypeCode is MessagePackString)
 			{
 				// nil or MPS (eventually string or byte[])
 				return;
 			}
 
-			if ( parameterName != null )
+			if (parameterName != null)
 			{
-				throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, "Do not convert {0} MessagePackObject to {1}.", instance.UnderlyingType, typeof( T ) ), parameterName );
+				throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "Do not convert {0} MessagePackObject to {1}.", instance.UnderlyingType, typeof(T)), parameterName);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<T>( instance );
+				ThrowInvalidTypeAs<T>(instance);
 			}
 		}
 
 		private static void ThrowCannotBeNilAs<T>()
 		{
-			throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "Do not convert nil MessagePackObject to {0}.", typeof( T ) ) );
+			throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "Do not convert nil MessagePackObject to {0}.", typeof(T)));
 		}
 
-		private static void ThrowInvalidTypeAs<T>( MessagePackObject instance )
+		private static void ThrowInvalidTypeAs<T>(MessagePackObject instance)
 		{
-			if ( instance._handleOrTypeCode is ValueTypeCode )
+			if (instance._handleOrTypeCode is ValueTypeCode)
 			{
-				throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "Do not convert {0} (binary:0x{2:x}) MessagePackObject to {1}.", instance.UnderlyingType, typeof( T ), instance._value ) );
+				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "Do not convert {0} (binary:0x{2:x}) MessagePackObject to {1}.", instance.UnderlyingType, typeof(T), instance._value));
 			}
 			else
 			{
-				throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "Do not convert {0} MessagePackObject to {1}.", instance.UnderlyingType, typeof( T ) ) );
+				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "Do not convert {0} MessagePackObject to {1}.", instance.UnderlyingType, typeof(T)));
 			}
 		}
 
-#endregion -- Utility Methods --
+		#endregion -- Utility Methods --
 
 		/// <summary>
 		///		Wraps specified object as <see cref="MessagePackObject"/> recursively.
@@ -1604,166 +1281,170 @@ private static void ThrowInvalidTypeAs<T>( MessagePackObject instance )
 		///		<paramref name="boxedValue"/> is not primitive value type, list of <see cref="MessagePackObject"/>,
 		///		dictionary of <see cref="MessagePackObject"/>, <see cref="String"/>, <see cref="Byte"/>[], or null.
 		/// </exception>
-		public static MessagePackObject FromObject( object boxedValue )
+		public static MessagePackObject FromObject(object boxedValue)
 		{
-			byte[] asByteArray;
-			string asString;
-			IEnumerable<byte> asByteEnumerable;
-			IEnumerable<char> asCharEnumerable;
-			IEnumerable<MessagePackObject> asEnumerable;
-			MessagePackObjectDictionary asDictionary;
-
 			// Nullable<T> is boxed as null or underlying value type, 
 			// so ( obj is Nullable<T> ) is always false.
-			if ( boxedValue == null )
+			if (boxedValue == null)
 			{
 				return Nil;
 			}
-			else if ( boxedValue is MessagePackObject )
+			else if (boxedValue is MessagePackObject)
 			{
-				return ( MessagePackObject )boxedValue;
+				return (MessagePackObject)boxedValue;
 			}
-			else if ( boxedValue is sbyte )
+			else if (boxedValue is sbyte)
 			{
-				return ( sbyte )boxedValue;
+				return (sbyte)boxedValue;
 			}
-			else if ( boxedValue is byte )
+			else if (boxedValue is byte)
 			{
-				return ( byte )boxedValue;
+				return (byte)boxedValue;
 			}
-			else if ( boxedValue is short )
+			else if (boxedValue is short)
 			{
-				return ( short )boxedValue;
+				return (short)boxedValue;
 			}
-			else if ( boxedValue is ushort )
+			else if (boxedValue is ushort)
 			{
-				return ( ushort )boxedValue;
+				return (ushort)boxedValue;
 			}
-			else if ( boxedValue is int )
+			else if (boxedValue is int)
 			{
-				return ( int )boxedValue;
+				return (int)boxedValue;
 			}
-			else if ( boxedValue is uint )
+			else if (boxedValue is uint)
 			{
-				return ( uint )boxedValue;
+				return (uint)boxedValue;
 			}
-			else if ( boxedValue is long )
+			else if (boxedValue is long)
 			{
-				return ( long )boxedValue;
+				return (long)boxedValue;
 			}
-			else if ( boxedValue is ulong )
+			else if (boxedValue is ulong)
 			{
-				return ( ulong )boxedValue;
+				return (ulong)boxedValue;
 			}
-			else if ( boxedValue is float )
+			else if (boxedValue is float)
 			{
-				return ( float )boxedValue;
+				return (float)boxedValue;
 			}
-			else if ( boxedValue is double )
+			else if (boxedValue is double)
 			{
-				return ( double )boxedValue;
+				return (double)boxedValue;
 			}
-			else if ( boxedValue is bool )
+			else if (boxedValue is bool)
 			{
-				return ( bool )boxedValue;
+				return (bool)boxedValue;
 			}
-			else if ( ( asByteArray = boxedValue as byte[] ) != null )
+			else if (boxedValue is byte[] asByteArray)
 			{
-				return new MessagePackObject( asByteArray );
+				return new MessagePackObject(asByteArray);
 			}
-			else if ( ( asString = boxedValue as string ) != null )
+			else if (boxedValue is string asString)
 			{
-				return new MessagePackObject( asString );
+				return new MessagePackObject(asString);
 			}
-			else if ( ( asByteEnumerable = boxedValue as IEnumerable<byte> ) != null )
+			else if (boxedValue is IEnumerable<byte> asByteEnumerable)
 			{
-				return new MessagePackObject( ( asByteEnumerable ).ToArray() );
+				return new MessagePackObject((asByteEnumerable).ToArray());
 			}
-			else if ( ( asCharEnumerable = boxedValue as IEnumerable<char> ) != null )
+			else if (boxedValue is Memory<byte> asByteMemory)
 			{
-				return new MessagePackObject( new String( ( asCharEnumerable ).ToArray() ) );
+				return new MessagePackObject(asByteMemory);
 			}
-			else if ( ( asEnumerable = boxedValue as IEnumerable<MessagePackObject> ) != null )
+			else if (boxedValue is ReadOnlyMemory<byte> asReadOnlyByteMemory)
 			{
-				var asList = boxedValue as IList<MessagePackObject>;
-				if ( asList != null )
-				{
-					return new MessagePackObject( asList, false );
-				}
-				else
-				{
-					return new MessagePackObject( ( asEnumerable ).ToArray(), true );
-				}
+				return new MessagePackObject(asReadOnlyByteMemory);
+			}
+			else if (boxedValue is IEnumerable<char> asCharEnumerable)
+			{
+				return new MessagePackObject(new string((asCharEnumerable).ToArray()));
+			}
+			else if (boxedValue is Memory<char> asCharMemory)
+			{
+				return new MessagePackObject(asCharMemory);
+			}
+			else if (boxedValue is ReadOnlyMemory<char> asReadOnlyCharMemory)
+			{
+				return new MessagePackObject(asReadOnlyCharMemory);
+			}
+			else if (boxedValue is IList<MessagePackObject> asList)
+			{
+				return new MessagePackObject(asList, false);
+			}
+			else if (boxedValue is IReadOnlyList<MessagePackObject> asReadOnlyList)
+			{
+				return new MessagePackObject(asReadOnlyList, true);
 			}
-			else if ( ( asDictionary = boxedValue as MessagePackObjectDictionary ) != null )
+			else if (boxedValue is IEnumerable<MessagePackObject> asEnumerable)
 			{
-				return new MessagePackObject( asDictionary, false );
+				return new MessagePackObject((asEnumerable).ToArray() as IList<MessagePackObject>, true);
 			}
-			else if ( boxedValue is MessagePackExtendedTypeObject )
+			else if (boxedValue is MessagePackObjectDictionary asDictionary)
 			{
-				return new MessagePackObject( ( MessagePackExtendedTypeObject )boxedValue );
+				return new MessagePackObject(asDictionary, false);
+			}
+#pragma warning disable CS0618
+			else if (boxedValue is MessagePackExtendedTypeObject mpext)
+			{
+				return new MessagePackObject(mpext);
+			}
+#pragma warning restore CS0618
+			else if (boxedValue is ExtensionTypeObject ext)
+			{
+				return new MessagePackObject(ext);
 			}
 
-			throw new MessageTypeException( String.Format( CultureInfo.CurrentCulture, "Type '{0}' is not supported.", boxedValue.GetType() ) );
+			throw new MessageTypeException(String.Format(CultureInfo.CurrentCulture, "Type '{0}' is not supported.", boxedValue.GetType()));
 		}
 
 		/// <summary>
 		///		Get boxed underlying value for this object.
 		/// </summary>
 		/// <returns>Boxed underlying value for this object.</returns>
-		public object ToObject()
+		public object? ToObject()
 		{
-			if ( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
 				return null;
 			}
 
-			var asType = this._handleOrTypeCode as ValueTypeCode;
-			if ( asType == null )
+			if (!(this._handleOrTypeCode is ValueTypeCode asType))
 			{
-				var asBinary = this._handleOrTypeCode as MessagePackString;
-				if ( asBinary != null )
+				if (this._handleOrTypeCode is MessagePackString asBinary)
 				{
 					var asString = asBinary.TryGetString();
-					if ( asString != null )
+					if (asString != null)
 					{
 						return asString;
 					}
 
-					return asBinary.UnsafeGetBuffer();
+					return asBinary.UnsafeGetMemory().ToArray();
 				}
 
-				var asList = this._handleOrTypeCode as IList<MessagePackObject>;
-				if ( asList != null )
+				if (this._handleOrTypeCode is IList<MessagePackObject> asList)
 				{
 					return asList;
 				}
 
-				var asDictionary = this._handleOrTypeCode as IDictionary<MessagePackObject, MessagePackObject>;
-				if ( asDictionary != null )
+				if (this._handleOrTypeCode is IDictionary<MessagePackObject, MessagePackObject> asDictionary)
 				{
 					return asDictionary;
 				}
 
-				// ReSharper disable HeuristicUnreachableCode
-				// ReSharper disable once ExpressionIsAlwaysNull
-				var asExtendedTypeObject = this._handleOrTypeCode as byte[];
-				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-				if ( asExtendedTypeObject != null )
+				if (this._handleOrTypeCode is ReadOnlySequence<byte> asExtendedTypeObject)
 				{
-					return MessagePackExtendedTypeObject.Unpack( unchecked( ( byte ) this._value ), asExtendedTypeObject );
+					return new ExtensionTypeObject(new ExtensionType(unchecked((long)this._value)), asExtendedTypeObject);
 				}
-				// ReSharper restore HeuristicUnreachableCode
 
-#if DEBUG
-				Contract.Assert( false, "Unknwon type:" + this._handleOrTypeCode );
-#endif // DEBUG
+				Debug.Fail($"Unexpected handle type: {this._handleOrTypeCode.GetType()}");
 				// ReSharper disable once HeuristicUnreachableCode
 				return null;
 			}
 			else
 			{
-				switch ( asType.TypeCode )
+				switch (asType.TypeCode)
 				{
 					case MessagePackValueTypeCode.Boolean:
 					{
@@ -1811,9 +1492,7 @@ public object ToObject()
 					}
 					default:
 					{
-#if DEBUG
-						Contract.Assert( false, "Unknwon type code:" + asType.TypeCode );
-#endif // DEBUG
+						Debug.Assert(false, $"Unknwon type code: {asType.TypeCode}");
 						// ReSharper disable once HeuristicUnreachableCode
 						return null;
 					}
@@ -1830,15 +1509,15 @@ public Timestamp AsTimestamp()
 		{
 			try
 			{
-				return Timestamp.Decode( this.AsMessagePackExtendedTypeObject() );
+				return Timestamp.Decode(this.AsMessagePackExtendedTypeObject());
 			}
-			catch(ArgumentException ex)
+			catch (ArgumentException ex)
 			{
-				throw new InvalidOperationException( ex.Message, ex );
+				throw new InvalidOperationException(ex.Message, ex);
 			}
 		}
 
-#region -- Structure Operator Overloads --
+		#region -- Structure Operator Overloads --
 
 		/// <summary>
 		///		Compare two instances are equal.
@@ -1848,9 +1527,9 @@ public Timestamp AsTimestamp()
 		/// <returns>
 		///		Whether value of <paramref name="left"/> and <paramref name="right"/> are equal each other or not.
 		/// </returns>
-		public static bool operator ==( MessagePackObject left, MessagePackObject right )
+		public static bool operator ==(MessagePackObject left, MessagePackObject right)
 		{
-			return left.Equals( right );
+			return left.Equals(right);
 		}
 
 		/// <summary>
@@ -1861,24 +1540,24 @@ public Timestamp AsTimestamp()
 		/// <returns>
 		///		Whether value of <paramref name="left"/> and <paramref name="right"/> are not equal each other or are equal.
 		/// </returns>
-		public static bool operator !=( MessagePackObject left, MessagePackObject right )
+		public static bool operator !=(MessagePackObject left, MessagePackObject right)
 		{
-			return !left.Equals( right );
+			return !left.Equals(right);
 		}
 
-#endregion -- Structure Operator Overloads --
+		#endregion -- Structure Operator Overloads --
 
 
-#region -- Conversion Operator Overloads --
+		#region -- Conversion Operator Overloads --
 
 		/// <summary>
 		///		Convert <see cref="MessagePackObject"/>[] instance to <see cref="MessagePackObject"/> instance.
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/>[] instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( MessagePackObject[] value )
+		public static implicit operator MessagePackObject(MessagePackObject[] value)
 		{
-			return new MessagePackObject( value, false );
+			return new MessagePackObject(value as IList<MessagePackObject>, false);
 		}
 
 		#endregion -- Conversion Operator Overloads --
@@ -1892,13 +1571,13 @@ public static implicit operator MessagePackObject( MessagePackObject[] value )
 		string DebugDump()
 		{
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if ( typeCode != null )
+			if (typeCode != null)
 			{
-				return String.Format( CultureInfo.InvariantCulture, "{0}([{1}]0x{0:X})", this._value, typeCode.Type );
+				return String.Format(CultureInfo.InvariantCulture, "{0}([{1}]0x{0:X})", this._value, typeCode.Type);
 			}
-			else if ( this._handleOrTypeCode != null )
+			else if (this._handleOrTypeCode != null)
 			{
-				return String.Format( CultureInfo.InvariantCulture, "{0}([{1}])", this._handleOrTypeCode, this._handleOrTypeCode.GetType() );
+				return String.Format(CultureInfo.InvariantCulture, "{0}([{1}])", this._handleOrTypeCode, this._handleOrTypeCode.GetType());
 			}
 			else
 			{
@@ -1908,9 +1587,9 @@ string DebugDump()
 #endif // DEBUG
 
 #if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-		[ Serializable ]
+		[Serializable]
 #endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-		private enum MessagePackValueTypeCode
+		internal enum MessagePackValueTypeCode
 		{
 			// ReSharper disable once UnusedMember.Local
 			Nil = 0,
@@ -1931,7 +1610,7 @@ private enum MessagePackValueTypeCode
 #if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		[Serializable]
 #endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-		private sealed class ValueTypeCode
+		internal sealed class ValueTypeCode
 		{
 			private readonly MessagePackValueTypeCode _typeCode;
 
@@ -1942,12 +1621,12 @@ public MessagePackValueTypeCode TypeCode
 
 			public bool IsSigned
 			{
-				get { return ( ( int )this._typeCode ) % 2 != 0; }
+				get { return ((int)this._typeCode) % 2 != 0; }
 			}
 
 			public bool IsInteger
 			{
-				get { return ( ( int )this._typeCode ) < 10; }
+				get { return ((int)this._typeCode) < 10; }
 			}
 
 			private readonly Type _type;
@@ -1957,17 +1636,15 @@ public Type Type
 				get { return this._type; }
 			}
 
-			internal ValueTypeCode( Type type, MessagePackValueTypeCode typeCode )
+			internal ValueTypeCode(Type type, MessagePackValueTypeCode typeCode)
 			{
 				this._type = type;
 				this._typeCode = typeCode;
 			}
 
-			public override string ToString()
-			{
+			public override string ToString() =>
 				// For debuggability.
-				return this._typeCode == MessagePackValueTypeCode.Object ? this._type.FullName : this._typeCode.ToString();
-			}
+				this._typeCode == MessagePackValueTypeCode.Object ? this._type.ToString() : this._typeCode.ToString()!;
 		}
 	}
 }
diff --git a/src/MsgPack/MessagePackObject.cs b/src/MsgPack/MessagePackObject.cs
index 293b71231..b8b8ff5de 100644
--- a/src/MsgPack/MessagePackObject.cs
+++ b/src/MsgPack/MessagePackObject.cs
@@ -1,33 +1,10 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+#pragma warning disable IDE0049
 
 using System;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 using System.Runtime.InteropServices;
 
 namespace MsgPack
@@ -38,7 +15,7 @@ namespace MsgPack
 	/// <summary>
 	///		Represents deserialized object of MsgPack.
 	/// </summary>
-	[StructLayout( LayoutKind.Auto )]
+	[StructLayout(LayoutKind.Auto)]
 	public partial struct MessagePackObject : IEquatable<MessagePackObject>
 	{
 		#region -- Constructors --
@@ -46,18 +23,18 @@ public partial struct MessagePackObject : IEquatable<MessagePackObject>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Boolean"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Boolean value )
+		public MessagePackObject(Boolean value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			this._value = value ? ( ulong )1 : 0;
+			this._value = value ? (ulong)1 : 0;
 			this._handleOrTypeCode = _booleanTypeCode;
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Byte"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Byte value )
+		public MessagePackObject(Byte value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
@@ -68,31 +45,31 @@ public MessagePackObject( Byte value )
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="SByte"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		[CLSCompliant( false )]
-		public MessagePackObject( SByte value )
+		[CLSCompliant(false)]
+		public MessagePackObject(SByte value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			this._value = unchecked( ( ulong )value );
+			this._value = unchecked((ulong)value);
 			this._handleOrTypeCode = _sbyteTypeCode;
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Int16"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Int16 value )
+		public MessagePackObject(Int16 value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			this._value = unchecked( ( ulong )value );
+			this._value = unchecked((ulong)value);
 			this._handleOrTypeCode = _int16TypeCode;
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="UInt16"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		[CLSCompliant( false )]
-		public MessagePackObject( UInt16 value )
+		[CLSCompliant(false)]
+		public MessagePackObject(UInt16 value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
@@ -103,19 +80,19 @@ public MessagePackObject( UInt16 value )
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Int32"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Int32 value )
+		public MessagePackObject(Int32 value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			this._value = unchecked( ( ulong )value );
+			this._value = unchecked((ulong)value);
 			this._handleOrTypeCode = _int32TypeCode;
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="UInt32"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		[CLSCompliant( false )]
-		public MessagePackObject( UInt32 value )
+		[CLSCompliant(false)]
+		public MessagePackObject(UInt32 value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
@@ -126,19 +103,19 @@ public MessagePackObject( UInt32 value )
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Int64"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Int64 value )
+		public MessagePackObject(Int64 value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			this._value = unchecked( ( ulong )value );
+			this._value = unchecked((ulong)value);
 			this._handleOrTypeCode = _int64TypeCode;
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="UInt64"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		[CLSCompliant( false )]
-		public MessagePackObject( UInt64 value )
+		[CLSCompliant(false)]
+		public MessagePackObject(UInt64 value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
@@ -149,27 +126,27 @@ public MessagePackObject( UInt64 value )
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Single"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Single value )
+		public MessagePackObject(Single value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			var bytes = BitConverter.GetBytes( value );
+			var bytes = BitConverter.GetBytes(value);
 			unchecked
 			{
 #pragma warning disable 0675
-				if( BitConverter.IsLittleEndian )
+				if (BitConverter.IsLittleEndian)
 				{
-					this._value |=  ( ulong )( bytes[ 3 ] << 24 );
-					this._value |=  ( ulong )( bytes[ 2 ] << 16 );
-					this._value |=  ( ulong )( bytes[ 1 ] << 8 );
-					this._value |=  bytes[ 0 ];
+					this._value |= (ulong)(bytes[3] << 24);
+					this._value |= (ulong)(bytes[2] << 16);
+					this._value |= (ulong)(bytes[1] << 8);
+					this._value |= bytes[0];
 				}
 				else
 				{
-					this._value |=  ( ulong )( bytes[ 0 ] << 24 );
-					this._value |=  ( ulong )( bytes[ 1 ] << 16 );
-					this._value |=  ( ulong )( bytes[ 2 ] << 8 );
-					this._value |=  bytes[ 3 ];
+					this._value |= (ulong)(bytes[0] << 24);
+					this._value |= (ulong)(bytes[1] << 16);
+					this._value |= (ulong)(bytes[2] << 8);
+					this._value |= bytes[3];
 				}
 #pragma warning restore 0675
 			}
@@ -179,28 +156,28 @@ public MessagePackObject( Single value )
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Double"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( Double value )
+		public MessagePackObject(Double value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			this._value = unchecked( ( ulong )BitConverter.DoubleToInt64Bits( value ) );
+			this._value = unchecked((ulong)BitConverter.DoubleToInt64Bits(value));
 			this._handleOrTypeCode = _doubleTypeCode;
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="String"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( String value )
+		public MessagePackObject(String value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			if ( value == null )
+			if (value == null)
 			{
 				this._handleOrTypeCode = null;
 			}
 			else
 			{
-				this._handleOrTypeCode = new MessagePackString( value );
+				this._handleOrTypeCode = new MessagePackString(value);
 			}
 		}
 		/// <summary>
@@ -211,8 +188,8 @@ public MessagePackObject( String value )
 		///		This constructor invokes <see cref="MessagePackObject(Byte[],Boolean)" /> with <c>false</c>, that means if you pass tha bytes array which is valid utf-8, resulting object can be <see cref="String" />,
 		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
 		/// </remarks>
-		public MessagePackObject( Byte[] value )
-			: this( value, false ) { }
+		public MessagePackObject(Byte[] value)
+			: this(value, false) { }
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
@@ -226,24 +203,24 @@ public MessagePackObject( Byte[] value )
 		///		then the resulting object can be <see cref="String" />,
 		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
 		/// </remarks>
-		public MessagePackObject( Byte[] value, bool isBinary )
+		public MessagePackObject(Byte[] value, bool isBinary)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
-			if ( value == null )
+			if (value == null)
 			{
 				this._handleOrTypeCode = null;
 			}
 			else
 			{
-				this._handleOrTypeCode = new MessagePackString( value, isBinary );
+				this._handleOrTypeCode = new MessagePackString(value, isBinary);
 			}
 		}
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="MessagePackExtendedTypeObject"/> instance.
 		/// </summary>
 		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
-		public MessagePackObject( MessagePackExtendedTypeObject value )
+		public MessagePackObject(MessagePackExtendedTypeObject value)
 		{
 			// trick: Avoid long boilerplate initialization.
 			this = new MessagePackObject();
@@ -261,16 +238,16 @@ public MessagePackObject( MessagePackExtendedTypeObject value )
 		/// <returns><see cref="Boolean" /> instance corresponds to this instance.</returns>
 		public Boolean AsBoolean()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Boolean>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean )
+			if (typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean)
 			{
-				ThrowInvalidTypeAs<bool>( this );
+				ThrowInvalidTypeAs<bool>(this);
 			}
-			
+
 			return this._value != 0;
 		}
 
@@ -280,54 +257,54 @@ public Boolean AsBoolean()
 		/// <returns><see cref="Byte" /> instance corresponds to this instance.</returns>
 		public Byte AsByte()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Byte>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Byte>( this );
+				ThrowInvalidTypeAs<Byte>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )Byte.MinValue;
-					const long maxValue = ( long )Byte.MaxValue;
-					
-					long asInt64 = unchecked( ( long )this._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)Byte.MinValue;
+					const long maxValue = (long)Byte.MaxValue;
+
+					long asInt64 = unchecked((long)this._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<Byte>( this );
+						ThrowInvalidTypeAs<Byte>(this);
 					}
 
-					return unchecked( ( Byte )asInt64 );
+					return unchecked((Byte)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Byte.MaxValue );
-					if( maxValue < this._value )
+					const ulong maxValue = unchecked((ulong)Byte.MaxValue);
+					if (maxValue < this._value)
 					{
-						ThrowInvalidTypeAs<Byte>( this );
+						ThrowInvalidTypeAs<Byte>(this);
 					}
-					
-					return ( Byte )this._value;
+
+					return (Byte)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Byte )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (Byte)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Byte )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (Byte)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Byte>( this );
-				return default( Byte ); // never reached
+				ThrowInvalidTypeAs<Byte>(this);
+				return default(Byte); // never reached
 			}
 		}
 
@@ -335,57 +312,57 @@ public Byte AsByte()
 		///		Convert this instance to <see cref="SByte" /> instance.
 		/// </summary>
 		/// <returns><see cref="SByte" /> instance corresponds to this instance.</returns>
-		[CLSCompliant( false )]
+		[CLSCompliant(false)]
 		public SByte AsSByte()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<SByte>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<SByte>( this );
+				ThrowInvalidTypeAs<SByte>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )SByte.MinValue;
-					const long maxValue = ( long )SByte.MaxValue;
-					
-					long asInt64 = unchecked( ( long )this._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)SByte.MinValue;
+					const long maxValue = (long)SByte.MaxValue;
+
+					long asInt64 = unchecked((long)this._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<SByte>( this );
+						ThrowInvalidTypeAs<SByte>(this);
 					}
 
-					return unchecked( ( SByte )asInt64 );
+					return unchecked((SByte)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )SByte.MaxValue );
-					if( maxValue < this._value )
+					const ulong maxValue = unchecked((ulong)SByte.MaxValue);
+					if (maxValue < this._value)
 					{
-						ThrowInvalidTypeAs<SByte>( this );
+						ThrowInvalidTypeAs<SByte>(this);
 					}
-					
-					return ( SByte )this._value;
+
+					return (SByte)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( SByte )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (SByte)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( SByte )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (SByte)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<SByte>( this );
-				return default( SByte ); // never reached
+				ThrowInvalidTypeAs<SByte>(this);
+				return default(SByte); // never reached
 			}
 		}
 
@@ -395,54 +372,54 @@ public SByte AsSByte()
 		/// <returns><see cref="Int16" /> instance corresponds to this instance.</returns>
 		public Int16 AsInt16()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Int16>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Int16>( this );
+				ThrowInvalidTypeAs<Int16>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )Int16.MinValue;
-					const long maxValue = ( long )Int16.MaxValue;
-					
-					long asInt64 = unchecked( ( long )this._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)Int16.MinValue;
+					const long maxValue = (long)Int16.MaxValue;
+
+					long asInt64 = unchecked((long)this._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<Int16>( this );
+						ThrowInvalidTypeAs<Int16>(this);
 					}
 
-					return unchecked( ( Int16 )asInt64 );
+					return unchecked((Int16)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Int16.MaxValue );
-					if( maxValue < this._value )
+					const ulong maxValue = unchecked((ulong)Int16.MaxValue);
+					if (maxValue < this._value)
 					{
-						ThrowInvalidTypeAs<Int16>( this );
+						ThrowInvalidTypeAs<Int16>(this);
 					}
-					
-					return ( Int16 )this._value;
+
+					return (Int16)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Int16 )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (Int16)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Int16 )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (Int16)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Int16>( this );
-				return default( Int16 ); // never reached
+				ThrowInvalidTypeAs<Int16>(this);
+				return default(Int16); // never reached
 			}
 		}
 
@@ -450,43 +427,43 @@ public Int16 AsInt16()
 		///		Convert this instance to <see cref="UInt16" /> instance.
 		/// </summary>
 		/// <returns><see cref="UInt16" /> instance corresponds to this instance.</returns>
-		[CLSCompliant( false )]
+		[CLSCompliant(false)]
 		public UInt16 AsUInt16()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<UInt16>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<UInt16>( this );
+				ThrowInvalidTypeAs<UInt16>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				const ulong maxValue = unchecked( ( ulong )UInt16.MaxValue );
-				
-				if( maxValue < this._value )
+				const ulong maxValue = unchecked((ulong)UInt16.MaxValue);
+
+				if (maxValue < this._value)
 				{
 					// Overflow or negative.
-					ThrowInvalidTypeAs<UInt16>( this );
+					ThrowInvalidTypeAs<UInt16>(this);
 				}
 
-				return unchecked( ( UInt16 )this._value );
+				return unchecked((UInt16)this._value);
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( UInt16 )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (UInt16)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( UInt16 )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (UInt16)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<UInt16>( this );
-				return default( UInt16 ); // never reached
+				ThrowInvalidTypeAs<UInt16>(this);
+				return default(UInt16); // never reached
 			}
 		}
 
@@ -496,54 +473,54 @@ public UInt16 AsUInt16()
 		/// <returns><see cref="Int32" /> instance corresponds to this instance.</returns>
 		public Int32 AsInt32()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Int32>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Int32>( this );
+				ThrowInvalidTypeAs<Int32>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )Int32.MinValue;
-					const long maxValue = ( long )Int32.MaxValue;
-					
-					long asInt64 = unchecked( ( long )this._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)Int32.MinValue;
+					const long maxValue = (long)Int32.MaxValue;
+
+					long asInt64 = unchecked((long)this._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<Int32>( this );
+						ThrowInvalidTypeAs<Int32>(this);
 					}
 
-					return unchecked( ( Int32 )asInt64 );
+					return unchecked((Int32)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Int32.MaxValue );
-					if( maxValue < this._value )
+					const ulong maxValue = unchecked((ulong)Int32.MaxValue);
+					if (maxValue < this._value)
 					{
-						ThrowInvalidTypeAs<Int32>( this );
+						ThrowInvalidTypeAs<Int32>(this);
 					}
-					
-					return ( Int32 )this._value;
+
+					return (Int32)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Int32 )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (Int32)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Int32 )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (Int32)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Int32>( this );
-				return default( Int32 ); // never reached
+				ThrowInvalidTypeAs<Int32>(this);
+				return default(Int32); // never reached
 			}
 		}
 
@@ -551,43 +528,43 @@ public Int32 AsInt32()
 		///		Convert this instance to <see cref="UInt32" /> instance.
 		/// </summary>
 		/// <returns><see cref="UInt32" /> instance corresponds to this instance.</returns>
-		[CLSCompliant( false )]
+		[CLSCompliant(false)]
 		public UInt32 AsUInt32()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<UInt32>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<UInt32>( this );
+				ThrowInvalidTypeAs<UInt32>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				const ulong maxValue = unchecked( ( ulong )UInt32.MaxValue );
-				
-				if( maxValue < this._value )
+				const ulong maxValue = unchecked((ulong)UInt32.MaxValue);
+
+				if (maxValue < this._value)
 				{
 					// Overflow or negative.
-					ThrowInvalidTypeAs<UInt32>( this );
+					ThrowInvalidTypeAs<UInt32>(this);
 				}
 
-				return unchecked( ( UInt32 )this._value );
+				return unchecked((UInt32)this._value);
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( UInt32 )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (UInt32)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( UInt32 )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (UInt32)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<UInt32>( this );
-				return default( UInt32 ); // never reached
+				ThrowInvalidTypeAs<UInt32>(this);
+				return default(UInt32); // never reached
 			}
 		}
 
@@ -597,45 +574,45 @@ public UInt32 AsUInt32()
 		/// <returns><see cref="Int64" /> instance corresponds to this instance.</returns>
 		public Int64 AsInt64()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Int64>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Int64>( this );
+				ThrowInvalidTypeAs<Int64>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					return unchecked( ( long )this._value );
+					return unchecked((long)this._value);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Int64.MaxValue );
-					if( maxValue < this._value )
+					const ulong maxValue = unchecked((ulong)Int64.MaxValue);
+					if (maxValue < this._value)
 					{
-						ThrowInvalidTypeAs<Int64>( this );
+						ThrowInvalidTypeAs<Int64>(this);
 					}
-					
-					return ( Int64 )this._value;
+
+					return (Int64)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Int64 )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (Int64)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Int64 )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (Int64)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Int64>( this );
-				return default( Int64 ); // never reached
+				ThrowInvalidTypeAs<Int64>(this);
+				return default(Int64); // never reached
 			}
 		}
 
@@ -643,44 +620,44 @@ public Int64 AsInt64()
 		///		Convert this instance to <see cref="UInt64" /> instance.
 		/// </summary>
 		/// <returns><see cref="UInt64" /> instance corresponds to this instance.</returns>
-		[CLSCompliant( false )]
+		[CLSCompliant(false)]
 		public UInt64 AsUInt64()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<UInt64>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<UInt64>( this );
+				ThrowInvalidTypeAs<UInt64>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					if( Int64.MaxValue < this._value )
+					if (Int64.MaxValue < this._value)
 					{
 						// Negative.
-						ThrowInvalidTypeAs<UInt64>( this );
+						ThrowInvalidTypeAs<UInt64>(this);
 					}
 				}
 
 				return this._value;
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( UInt64 )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (UInt64)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( UInt64 )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (UInt64)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<UInt64>( this );
-				return default( UInt64 ); // never reached
+				ThrowInvalidTypeAs<UInt64>(this);
+				return default(UInt64); // never reached
 			}
 		}
 
@@ -690,39 +667,39 @@ public UInt64 AsUInt64()
 		/// <returns><see cref="Single" /> instance corresponds to this instance.</returns>
 		public Single AsSingle()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Single>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<float>( this );
+				ThrowInvalidTypeAs<float>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					return ( float )( unchecked( ( long )this._value ) );
+					return (float)(unchecked((long)this._value));
 				}
 				else
 				{
-					return ( float )this._value;
+					return (float)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Single )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (Single)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Single )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (Single)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<float>( this );
-				return default( float ); // never reached
+				ThrowInvalidTypeAs<float>(this);
+				return default(float); // never reached
 			}
 		}
 
@@ -732,39 +709,39 @@ public Single AsSingle()
 		/// <returns><see cref="Double" /> instance corresponds to this instance.</returns>
 		public Double AsDouble()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<Double>();
 			}
 			var typeCode = this._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<double>( this );
+				ThrowInvalidTypeAs<double>(this);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					return ( double )( unchecked( ( long )this._value ) );
+					return (double)(unchecked((long)this._value));
 				}
 				else
 				{
-					return ( double )this._value;
+					return (double)this._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Double )BitConverter.Int64BitsToDouble( unchecked( ( long )this._value ) );
+				return (Double)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Double )BitConverter.ToSingle( BitConverter.GetBytes( this._value ), 0 );
+				return (Double)BitConverter.ToSingle(BitConverter.GetBytes(this._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<double>( this );
-				return default( double ); // never reached
+				ThrowInvalidTypeAs<double>(this);
+				return default(double); // never reached
 			}
 		}
 
@@ -774,16 +751,16 @@ public Double AsDouble()
 		/// <returns><see cref="String" /> instance corresponds to this instance.</returns>
 		public String AsString()
 		{
-			VerifyUnderlyingRawType<string>( this, null );
+			VerifyUnderlyingRawType<string>(this, null);
 
-			if( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
 				// nil
 				return null;
 			}
 
 			var asString = this._handleOrTypeCode as MessagePackString;
-			Contract.Assert( asString != null );
+			Contract.Assert(asString != null);
 			return asString.GetString();
 		}
 
@@ -793,16 +770,16 @@ public String AsString()
 		/// <returns><see cref="Byte" />[] instance corresponds to this instance.</returns>
 		public Byte[] AsBinary()
 		{
-			VerifyUnderlyingRawType<byte[]>( this, null  );
+			VerifyUnderlyingRawType<byte[]>(this, null);
 
-			if( this._handleOrTypeCode == null )
+			if (this._handleOrTypeCode == null)
 			{
 				// nil
 				return null;
 			}
 
 			var asString = this._handleOrTypeCode as MessagePackString;
-			Contract.Assert( asString != null );
+			Contract.Assert(asString != null);
 			return asString.GetBytes();
 		}
 
@@ -812,13 +789,13 @@ public Byte[] AsBinary()
 		/// <returns><see cref="MessagePackExtendedTypeObject" /> instance corresponds to this instance.</returns>
 		public MessagePackExtendedTypeObject AsMessagePackExtendedTypeObject()
 		{
-			if( this.IsNil )
+			if (this.IsNil)
 			{
 				ThrowCannotBeNilAs<MessagePackExtendedTypeObject>();
 			}
-			VerifyUnderlyingType<MessagePackExtendedTypeObject>( this, null  );
+			VerifyUnderlyingType<MessagePackExtendedTypeObject>(this, null);
 
-			return MessagePackExtendedTypeObject.Unpack( unchecked( ( byte )this._value ), this._handleOrTypeCode as byte[] );
+			return MessagePackExtendedTypeObject.Unpack(unchecked((byte)this._value), this._handleOrTypeCode as byte[]);
 		}
 
 		#endregion -- Primitive Type Conversion Methods --
@@ -831,12 +808,12 @@ public MessagePackExtendedTypeObject AsMessagePackExtendedTypeObject()
 		/// </summary>
 		/// <param name="value"><see cref="Boolean" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Boolean value )
+		public static implicit operator MessagePackObject(Boolean value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			result._value = value ? ( ulong )1 : 0;
+			result._value = value ? (ulong)1 : 0;
 			result._handleOrTypeCode = _booleanTypeCode;
 			return result;
 		}
@@ -846,7 +823,7 @@ public static implicit operator MessagePackObject( Boolean value )
 		/// </summary>
 		/// <param name="value"><see cref="Byte" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Byte value )
+		public static implicit operator MessagePackObject(Byte value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
@@ -861,13 +838,13 @@ public static implicit operator MessagePackObject( Byte value )
 		/// </summary>
 		/// <param name="value"><see cref="SByte" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static implicit operator MessagePackObject( SByte value )
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(SByte value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			result._value = unchecked( ( ulong )value );
+			result._value = unchecked((ulong)value);
 			result._handleOrTypeCode = _sbyteTypeCode;
 			return result;
 		}
@@ -877,12 +854,12 @@ public static implicit operator MessagePackObject( SByte value )
 		/// </summary>
 		/// <param name="value"><see cref="Int16" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Int16 value )
+		public static implicit operator MessagePackObject(Int16 value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			result._value = unchecked( ( ulong )value );
+			result._value = unchecked((ulong)value);
 			result._handleOrTypeCode = _int16TypeCode;
 			return result;
 		}
@@ -892,8 +869,8 @@ public static implicit operator MessagePackObject( Int16 value )
 		/// </summary>
 		/// <param name="value"><see cref="UInt16" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static implicit operator MessagePackObject( UInt16 value )
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(UInt16 value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
@@ -908,12 +885,12 @@ public static implicit operator MessagePackObject( UInt16 value )
 		/// </summary>
 		/// <param name="value"><see cref="Int32" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Int32 value )
+		public static implicit operator MessagePackObject(Int32 value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			result._value = unchecked( ( ulong )value );
+			result._value = unchecked((ulong)value);
 			result._handleOrTypeCode = _int32TypeCode;
 			return result;
 		}
@@ -923,8 +900,8 @@ public static implicit operator MessagePackObject( Int32 value )
 		/// </summary>
 		/// <param name="value"><see cref="UInt32" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static implicit operator MessagePackObject( UInt32 value )
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(UInt32 value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
@@ -939,12 +916,12 @@ public static implicit operator MessagePackObject( UInt32 value )
 		/// </summary>
 		/// <param name="value"><see cref="Int64" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Int64 value )
+		public static implicit operator MessagePackObject(Int64 value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			result._value = unchecked( ( ulong )value );
+			result._value = unchecked((ulong)value);
 			result._handleOrTypeCode = _int64TypeCode;
 			return result;
 		}
@@ -954,8 +931,8 @@ public static implicit operator MessagePackObject( Int64 value )
 		/// </summary>
 		/// <param name="value"><see cref="UInt64" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static implicit operator MessagePackObject( UInt64 value )
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(UInt64 value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
@@ -970,28 +947,28 @@ public static implicit operator MessagePackObject( UInt64 value )
 		/// </summary>
 		/// <param name="value"><see cref="Single" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Single value )
+		public static implicit operator MessagePackObject(Single value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			var bytes = BitConverter.GetBytes( value );
+			var bytes = BitConverter.GetBytes(value);
 			unchecked
 			{
 #pragma warning disable 0675
-				if( BitConverter.IsLittleEndian )
+				if (BitConverter.IsLittleEndian)
 				{
-					result._value |=  ( ulong )( bytes[ 3 ] << 24 );
-					result._value |=  ( ulong )( bytes[ 2 ] << 16 );
-					result._value |=  ( ulong )( bytes[ 1 ] << 8 );
-					result._value |=  bytes[ 0 ];
+					result._value |= (ulong)(bytes[3] << 24);
+					result._value |= (ulong)(bytes[2] << 16);
+					result._value |= (ulong)(bytes[1] << 8);
+					result._value |= bytes[0];
 				}
 				else
 				{
-					result._value |=  ( ulong )( bytes[ 0 ] << 24 );
-					result._value |=  ( ulong )( bytes[ 1 ] << 16 );
-					result._value |=  ( ulong )( bytes[ 2 ] << 8 );
-					result._value |=  bytes[ 3 ];
+					result._value |= (ulong)(bytes[0] << 24);
+					result._value |= (ulong)(bytes[1] << 16);
+					result._value |= (ulong)(bytes[2] << 8);
+					result._value |= bytes[3];
 				}
 #pragma warning restore 0675
 			}
@@ -1004,12 +981,12 @@ public static implicit operator MessagePackObject( Single value )
 		/// </summary>
 		/// <param name="value"><see cref="Double" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Double value )
+		public static implicit operator MessagePackObject(Double value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			result._value = unchecked( ( ulong )BitConverter.DoubleToInt64Bits( value ) );
+			result._value = unchecked((ulong)BitConverter.DoubleToInt64Bits(value));
 			result._handleOrTypeCode = _doubleTypeCode;
 			return result;
 		}
@@ -1019,18 +996,18 @@ public static implicit operator MessagePackObject( Double value )
 		/// </summary>
 		/// <param name="value"><see cref="String" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( String value )
+		public static implicit operator MessagePackObject(String value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			if ( value == null )
+			if (value == null)
 			{
 				result._handleOrTypeCode = null;
 			}
 			else
 			{
-				result._handleOrTypeCode = new MessagePackString( value );
+				result._handleOrTypeCode = new MessagePackString(value);
 			}
 			return result;
 		}
@@ -1040,18 +1017,18 @@ public static implicit operator MessagePackObject( String value )
 		/// </summary>
 		/// <param name="value"><see cref="Byte" />[] instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( Byte[] value )
+		public static implicit operator MessagePackObject(Byte[] value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
 			result = new MessagePackObject();
-			if ( value == null )
+			if (value == null)
 			{
 				result._handleOrTypeCode = null;
 			}
 			else
 			{
-				result._handleOrTypeCode = new MessagePackString( value, false );
+				result._handleOrTypeCode = new MessagePackString(value, false);
 			}
 			return result;
 		}
@@ -1061,7 +1038,7 @@ public static implicit operator MessagePackObject( Byte[] value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackExtendedTypeObject" /> instance.</param>
 		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
-		public static implicit operator MessagePackObject( MessagePackExtendedTypeObject value )
+		public static implicit operator MessagePackObject(MessagePackExtendedTypeObject value)
 		{
 			MessagePackObject result;
 			// trick: Avoid long boilerplate initialization.
@@ -1077,18 +1054,18 @@ public static implicit operator MessagePackObject( MessagePackExtendedTypeObject
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Boolean" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Boolean( MessagePackObject value )
+		public static explicit operator Boolean(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Boolean>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean )
+			if (typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean)
 			{
-				ThrowInvalidTypeAs<bool>( value );
+				ThrowInvalidTypeAs<bool>(value);
 			}
-			
+
 			return value._value != 0;
 		}
 
@@ -1097,56 +1074,56 @@ public static explicit operator Boolean( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Byte" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Byte( MessagePackObject value )
+		public static explicit operator Byte(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Byte>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Byte>( value );
+				ThrowInvalidTypeAs<Byte>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )Byte.MinValue;
-					const long maxValue = ( long )Byte.MaxValue;
-					
-					long asInt64 = unchecked( ( long )value._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)Byte.MinValue;
+					const long maxValue = (long)Byte.MaxValue;
+
+					long asInt64 = unchecked((long)value._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<Byte>( value );
+						ThrowInvalidTypeAs<Byte>(value);
 					}
 
-					return unchecked( ( Byte )asInt64 );
+					return unchecked((Byte)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Byte.MaxValue );
-					if( maxValue < value._value )
+					const ulong maxValue = unchecked((ulong)Byte.MaxValue);
+					if (maxValue < value._value)
 					{
-						ThrowInvalidTypeAs<Byte>( value );
+						ThrowInvalidTypeAs<Byte>(value);
 					}
-					
-					return ( Byte )value._value;
+
+					return (Byte)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Byte )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (Byte)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Byte )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (Byte)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Byte>( value );
-				return default( Byte ); // never reached
+				ThrowInvalidTypeAs<Byte>(value);
+				return default(Byte); // never reached
 			}
 		}
 
@@ -1155,57 +1132,57 @@ public static explicit operator Byte( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="SByte" /> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static explicit operator SByte( MessagePackObject value )
+		[CLSCompliant(false)]
+		public static explicit operator SByte(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<SByte>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<SByte>( value );
+				ThrowInvalidTypeAs<SByte>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )SByte.MinValue;
-					const long maxValue = ( long )SByte.MaxValue;
-					
-					long asInt64 = unchecked( ( long )value._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)SByte.MinValue;
+					const long maxValue = (long)SByte.MaxValue;
+
+					long asInt64 = unchecked((long)value._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<SByte>( value );
+						ThrowInvalidTypeAs<SByte>(value);
 					}
 
-					return unchecked( ( SByte )asInt64 );
+					return unchecked((SByte)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )SByte.MaxValue );
-					if( maxValue < value._value )
+					const ulong maxValue = unchecked((ulong)SByte.MaxValue);
+					if (maxValue < value._value)
 					{
-						ThrowInvalidTypeAs<SByte>( value );
+						ThrowInvalidTypeAs<SByte>(value);
 					}
-					
-					return ( SByte )value._value;
+
+					return (SByte)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( SByte )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (SByte)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( SByte )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (SByte)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<SByte>( value );
-				return default( SByte ); // never reached
+				ThrowInvalidTypeAs<SByte>(value);
+				return default(SByte); // never reached
 			}
 		}
 
@@ -1214,56 +1191,56 @@ public static explicit operator SByte( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Int16" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Int16( MessagePackObject value )
+		public static explicit operator Int16(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Int16>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Int16>( value );
+				ThrowInvalidTypeAs<Int16>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )Int16.MinValue;
-					const long maxValue = ( long )Int16.MaxValue;
-					
-					long asInt64 = unchecked( ( long )value._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)Int16.MinValue;
+					const long maxValue = (long)Int16.MaxValue;
+
+					long asInt64 = unchecked((long)value._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<Int16>( value );
+						ThrowInvalidTypeAs<Int16>(value);
 					}
 
-					return unchecked( ( Int16 )asInt64 );
+					return unchecked((Int16)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Int16.MaxValue );
-					if( maxValue < value._value )
+					const ulong maxValue = unchecked((ulong)Int16.MaxValue);
+					if (maxValue < value._value)
 					{
-						ThrowInvalidTypeAs<Int16>( value );
+						ThrowInvalidTypeAs<Int16>(value);
 					}
-					
-					return ( Int16 )value._value;
+
+					return (Int16)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Int16 )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (Int16)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Int16 )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (Int16)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Int16>( value );
-				return default( Int16 ); // never reached
+				ThrowInvalidTypeAs<Int16>(value);
+				return default(Int16); // never reached
 			}
 		}
 
@@ -1272,43 +1249,43 @@ public static explicit operator Int16( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="UInt16" /> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static explicit operator UInt16( MessagePackObject value )
+		[CLSCompliant(false)]
+		public static explicit operator UInt16(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<UInt16>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<UInt16>( value );
+				ThrowInvalidTypeAs<UInt16>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				const ulong maxValue = unchecked( ( ulong )UInt16.MaxValue );
-				
-				if( maxValue < value._value )
+				const ulong maxValue = unchecked((ulong)UInt16.MaxValue);
+
+				if (maxValue < value._value)
 				{
 					// Overflow or negative.
-					ThrowInvalidTypeAs<UInt16>( value );
+					ThrowInvalidTypeAs<UInt16>(value);
 				}
 
-				return unchecked( ( UInt16 )value._value );
+				return unchecked((UInt16)value._value);
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( UInt16 )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (UInt16)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( UInt16 )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (UInt16)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<UInt16>( value );
-				return default( UInt16 ); // never reached
+				ThrowInvalidTypeAs<UInt16>(value);
+				return default(UInt16); // never reached
 			}
 		}
 
@@ -1317,56 +1294,56 @@ public static explicit operator UInt16( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Int32" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Int32( MessagePackObject value )
+		public static explicit operator Int32(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Int32>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Int32>( value );
+				ThrowInvalidTypeAs<Int32>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					const long minValue = ( long )Int32.MinValue;
-					const long maxValue = ( long )Int32.MaxValue;
-					
-					long asInt64 = unchecked( ( long )value._value );
-					if( asInt64 < minValue || maxValue < asInt64 )
+					const long minValue = (long)Int32.MinValue;
+					const long maxValue = (long)Int32.MaxValue;
+
+					long asInt64 = unchecked((long)value._value);
+					if (asInt64 < minValue || maxValue < asInt64)
 					{
-						ThrowInvalidTypeAs<Int32>( value );
+						ThrowInvalidTypeAs<Int32>(value);
 					}
 
-					return unchecked( ( Int32 )asInt64 );
+					return unchecked((Int32)asInt64);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Int32.MaxValue );
-					if( maxValue < value._value )
+					const ulong maxValue = unchecked((ulong)Int32.MaxValue);
+					if (maxValue < value._value)
 					{
-						ThrowInvalidTypeAs<Int32>( value );
+						ThrowInvalidTypeAs<Int32>(value);
 					}
-					
-					return ( Int32 )value._value;
+
+					return (Int32)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Int32 )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (Int32)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Int32 )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (Int32)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Int32>( value );
-				return default( Int32 ); // never reached
+				ThrowInvalidTypeAs<Int32>(value);
+				return default(Int32); // never reached
 			}
 		}
 
@@ -1375,43 +1352,43 @@ public static explicit operator Int32( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="UInt32" /> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static explicit operator UInt32( MessagePackObject value )
+		[CLSCompliant(false)]
+		public static explicit operator UInt32(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<UInt32>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<UInt32>( value );
+				ThrowInvalidTypeAs<UInt32>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				const ulong maxValue = unchecked( ( ulong )UInt32.MaxValue );
-				
-				if( maxValue < value._value )
+				const ulong maxValue = unchecked((ulong)UInt32.MaxValue);
+
+				if (maxValue < value._value)
 				{
 					// Overflow or negative.
-					ThrowInvalidTypeAs<UInt32>( value );
+					ThrowInvalidTypeAs<UInt32>(value);
 				}
 
-				return unchecked( ( UInt32 )value._value );
+				return unchecked((UInt32)value._value);
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( UInt32 )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (UInt32)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( UInt32 )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (UInt32)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<UInt32>( value );
-				return default( UInt32 ); // never reached
+				ThrowInvalidTypeAs<UInt32>(value);
+				return default(UInt32); // never reached
 			}
 		}
 
@@ -1420,47 +1397,47 @@ public static explicit operator UInt32( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Int64" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Int64( MessagePackObject value )
+		public static explicit operator Int64(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Int64>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<Int64>( value );
+				ThrowInvalidTypeAs<Int64>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					return unchecked( ( long )value._value );
+					return unchecked((long)value._value);
 				}
 				else
 				{
-					const ulong maxValue = unchecked( ( ulong )Int64.MaxValue );
-					if( maxValue < value._value )
+					const ulong maxValue = unchecked((ulong)Int64.MaxValue);
+					if (maxValue < value._value)
 					{
-						ThrowInvalidTypeAs<Int64>( value );
+						ThrowInvalidTypeAs<Int64>(value);
 					}
-					
-					return ( Int64 )value._value;
+
+					return (Int64)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Int64 )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (Int64)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Int64 )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (Int64)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<Int64>( value );
-				return default( Int64 ); // never reached
+				ThrowInvalidTypeAs<Int64>(value);
+				return default(Int64); // never reached
 			}
 		}
 
@@ -1469,44 +1446,44 @@ public static explicit operator Int64( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="UInt64" /> instance corresponds to <paramref name="value"/>.</returns>
-		[CLSCompliant( false )]
-		public static explicit operator UInt64( MessagePackObject value )
+		[CLSCompliant(false)]
+		public static explicit operator UInt64(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<UInt64>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<UInt64>( value );
+				ThrowInvalidTypeAs<UInt64>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					if( Int64.MaxValue < value._value )
+					if (Int64.MaxValue < value._value)
 					{
 						// Negative.
-						ThrowInvalidTypeAs<UInt64>( value );
+						ThrowInvalidTypeAs<UInt64>(value);
 					}
 				}
 
 				return value._value;
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( UInt64 )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (UInt64)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( UInt64 )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (UInt64)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<UInt64>( value );
-				return default( UInt64 ); // never reached
+				ThrowInvalidTypeAs<UInt64>(value);
+				return default(UInt64); // never reached
 			}
 		}
 
@@ -1515,41 +1492,41 @@ public static explicit operator UInt64( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Single" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Single( MessagePackObject value )
+		public static explicit operator Single(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Single>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<float>( value );
+				ThrowInvalidTypeAs<float>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					return ( float )( unchecked( ( long )value._value ) );
+					return (float)(unchecked((long)value._value));
 				}
 				else
 				{
-					return ( float )value._value;
+					return (float)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Single )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (Single)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Single )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (Single)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<float>( value );
-				return default( float ); // never reached
+				ThrowInvalidTypeAs<float>(value);
+				return default(float); // never reached
 			}
 		}
 
@@ -1558,41 +1535,41 @@ public static explicit operator Single( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Double" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Double( MessagePackObject value )
+		public static explicit operator Double(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<Double>();
 			}
 			var typeCode = value._handleOrTypeCode as ValueTypeCode;
-			if( typeCode == null )
+			if (typeCode == null)
 			{
-				ThrowInvalidTypeAs<double>( value );
+				ThrowInvalidTypeAs<double>(value);
 			}
-			
-			if( typeCode.IsInteger )
+
+			if (typeCode.IsInteger)
 			{
-				if( typeCode.IsSigned )
+				if (typeCode.IsSigned)
 				{
-					return ( double )( unchecked( ( long )value._value ) );
+					return (double)(unchecked((long)value._value));
 				}
 				else
 				{
-					return ( double )value._value;
+					return (double)value._value;
 				}
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Double )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
 			{
-				return ( Double )BitConverter.Int64BitsToDouble( unchecked( ( long )value._value ) );
+				return (Double)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
 			}
-			else if( typeCode.TypeCode == MessagePackValueTypeCode.Single )
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
 			{
-				return ( Double )BitConverter.ToSingle( BitConverter.GetBytes( value._value ), 0 );
+				return (Double)BitConverter.ToSingle(BitConverter.GetBytes(value._value), 0);
 			}
 			else
 			{
-				ThrowInvalidTypeAs<double>( value );
-				return default( double ); // never reached
+				ThrowInvalidTypeAs<double>(value);
+				return default(double); // never reached
 			}
 		}
 
@@ -1601,18 +1578,18 @@ public static explicit operator Double( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="String" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator String( MessagePackObject value )
+		public static explicit operator String(MessagePackObject value)
 		{
-			VerifyUnderlyingRawType<string>( value, "value" );
+			VerifyUnderlyingRawType<string>(value, "value");
 
-			if( value._handleOrTypeCode == null )
+			if (value._handleOrTypeCode == null)
 			{
 				// nil
 				return null;
 			}
 
 			var asString = value._handleOrTypeCode as MessagePackString;
-			Contract.Assert( asString != null );
+			Contract.Assert(asString != null);
 			return asString.GetString();
 		}
 
@@ -1621,18 +1598,18 @@ public static explicit operator String( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="Byte" />[] instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator Byte[]( MessagePackObject value )
+		public static explicit operator Byte[](MessagePackObject value)
 		{
-			VerifyUnderlyingRawType<byte[]>( value, "value"  );
+			VerifyUnderlyingRawType<byte[]>(value, "value");
 
-			if( value._handleOrTypeCode == null )
+			if (value._handleOrTypeCode == null)
 			{
 				// nil
 				return null;
 			}
 
 			var asString = value._handleOrTypeCode as MessagePackString;
-			Contract.Assert( asString != null );
+			Contract.Assert(asString != null);
 			return asString.GetBytes();
 		}
 
@@ -1641,15 +1618,15 @@ public static explicit operator Byte[]( MessagePackObject value )
 		/// </summary>
 		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
 		/// <returns><see cref="MessagePackExtendedTypeObject" /> instance corresponds to <paramref name="value"/>.</returns>
-		public static explicit operator MessagePackExtendedTypeObject( MessagePackObject value )
+		public static explicit operator MessagePackExtendedTypeObject(MessagePackObject value)
 		{
-			if( value.IsNil )
+			if (value.IsNil)
 			{
 				ThrowCannotBeNilAs<MessagePackExtendedTypeObject>();
 			}
-			VerifyUnderlyingType<MessagePackExtendedTypeObject>( value, "value"  );
+			VerifyUnderlyingType<MessagePackExtendedTypeObject>(value, "value");
 
-			return MessagePackExtendedTypeObject.Unpack( unchecked( ( byte )value._value ), value._handleOrTypeCode as byte[] );
+			return MessagePackExtendedTypeObject.Unpack(unchecked((byte)value._value), value._handleOrTypeCode as byte[]);
 		}
 
 		#endregion -- Conversion Operator Overloads --
diff --git a/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs b/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs
index 92cf34824..f752786b9 100644
--- a/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.Enumerator.cs
@@ -1,39 +1,15 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 
 namespace MsgPack
 {
-	partial class MessagePackObjectDictionary
+	public partial class MessagePackObjectDictionary
 	{
 		/// <summary>
 		///		Enumerates the elements of a <see cref="MessagePackObjectDictionary"/> in order.
@@ -84,7 +60,7 @@ DictionaryEntry IDictionaryEnumerator.Entry
 				get
 				{
 					var entry = this.GetCurrentStrict();
-					return new DictionaryEntry( entry.Key, entry.Value );
+					return new DictionaryEntry(entry.Key, entry.Value);
 				}
 			}
 
@@ -102,29 +78,29 @@ internal KeyValuePair<MessagePackObject, MessagePackObject> GetCurrentStrict()
 			{
 				this.VerifyVersion();
 
-				if ( this._position == BeforeHead || this._position == End )
+				if (this._position == BeforeHead || this._position == End)
 				{
-					throw new InvalidOperationException( "The enumerator is positioned before the first element of the collection or after the last element." );
+					throw new InvalidOperationException("The enumerator is positioned before the first element of the collection or after the last element.");
 				}
 
 				return this._current;
 			}
 
-			internal Enumerator( MessagePackObjectDictionary dictionary )
+			internal Enumerator(MessagePackObjectDictionary dictionary)
 				: this()
 			{
-				Contract.Assert( dictionary != null, "dictionary != null" );
+				Debug.Assert(dictionary != null, "dictionary != null");
 
-				this = default( Enumerator );
+				this = default(Enumerator);
 				this._underlying = dictionary;
 				this.ResetCore();
 			}
 
 			internal void VerifyVersion()
 			{
-				if ( this._underlying != null && this._underlying._version != this._initialVersion )
+				if (this._underlying != null && this._underlying._version != this._initialVersion)
 				{
-					throw new InvalidOperationException( "The collection was modified after the enumerator was created." );
+					throw new InvalidOperationException("The collection was modified after the enumerator was created.");
 				}
 			}
 
@@ -148,14 +124,14 @@ public void Dispose()
 			///	</exception>
 			public bool MoveNext()
 			{
-				if ( this._position == End )
+				if (this._position == End)
 				{
 					return false;
 				}
 
-				if ( this._position == IsDictionary )
+				if (this._position == IsDictionary)
 				{
-					if ( !this._enumerator.MoveNext() )
+					if (!this._enumerator.MoveNext())
 					{
 						return false;
 					}
@@ -164,9 +140,10 @@ public bool MoveNext()
 					return true;
 				}
 
-				if ( this._position == BeforeHead )
+				if (this._position == BeforeHead)
 				{
-					if ( this._underlying._keys.Count == 0 )
+#warning TODO: NRE
+					if (this._underlying._keys.Count == 0)
 					{
 						this._position = End;
 						return false;
@@ -180,13 +157,15 @@ public bool MoveNext()
 					this._position++;
 				}
 
-				if ( this._position == this._underlying._keys.Count )
+#warning TODO: NRE
+				if (this._position == this._underlying._keys.Count)
 				{
 					this._position = End;
 					return false;
 				}
 
-				this._current = new KeyValuePair<MessagePackObject, MessagePackObject>( this._underlying._keys[ this._position ], this._underlying._values[ this._position ] );
+#warning TODO: NRE
+				this._current = new KeyValuePair<MessagePackObject, MessagePackObject>(this._underlying._keys[this._position], this._underlying._values[this._position]);
 				return true;
 			}
 
@@ -204,9 +183,9 @@ void IEnumerator.Reset()
 			internal void ResetCore()
 			{
 				this._initialVersion = this._underlying._version;
-				this._current = default( KeyValuePair<MessagePackObject, MessagePackObject> );
+				this._current = default(KeyValuePair<MessagePackObject, MessagePackObject>);
 				this._initialVersion = this._underlying._version;
-				if ( this._underlying._dictionary != null )
+				if (this._underlying._dictionary != null)
 				{
 					this._enumerator = this._underlying._dictionary.GetEnumerator();
 					this._position = IsDictionary;
@@ -223,7 +202,7 @@ internal void ResetCore()
 		/// </summary>
 		private struct DictionaryEnumerator : IDictionaryEnumerator
 		{
-			private IDictionaryEnumerator _underlying;
+			private readonly IDictionaryEnumerator _underlying;
 
 			/// <summary>
 			///		Gets the element at the current position of the enumerator.
@@ -234,10 +213,7 @@ private struct DictionaryEnumerator : IDictionaryEnumerator
 			/// <exception cref="InvalidOperationException">
 			///		The enumerator is positioned before the first element of the collection or after the last element. 
 			/// </exception>
-			public object Current
-			{
-				get { return this._underlying.Entry; }
-			}
+			public object Current => this._underlying.Entry;
 
 			/// <summary>
 			///		Gets the element at the current position of the enumerator.
@@ -248,10 +224,7 @@ public object Current
 			/// <exception cref="T:System.InvalidOperationException">
 			///		The enumerator is positioned before the first element of the collection or after the last element. 
 			///	</exception>
-			public DictionaryEntry Entry
-			{
-				get { return this._underlying.Entry; }
-			}
+			public DictionaryEntry Entry => this._underlying.Entry;
 
 			/// <summary>
 			///		Gets the key of the element at the current position of the enumerator.
@@ -262,10 +235,7 @@ public DictionaryEntry Entry
 			/// <exception cref="T:System.InvalidOperationException">
 			///		The enumerator is positioned before the first element of the collection or after the last element. 
 			///	</exception>
-			public object Key
-			{
-				get { return this.Entry.Key; }
-			}
+			public object Key => this.Entry.Key;
 
 			/// <summary>
 			///		Gets the value of the element at the current position of the enumerator.
@@ -276,17 +246,14 @@ public object Key
 			/// <exception cref="T:System.InvalidOperationException">
 			///		The enumerator is positioned before the first element of the collection or after the last element. 
 			///	</exception>
-			public object Value
-			{
-				get { return this.Entry.Value; }
-			}
+			public object? Value => this.Entry.Value;
 
-			internal DictionaryEnumerator( MessagePackObjectDictionary dictionary )
+			internal DictionaryEnumerator(MessagePackObjectDictionary dictionary)
 				: this()
 			{
-				Contract.Assert( dictionary != null, "dictionary != null" );
+				Debug.Assert(dictionary != null, "dictionary != null");
 
-				this._underlying = new Enumerator( dictionary );
+				this._underlying = new Enumerator(dictionary);
 			}
 
 			/// <summary>
@@ -299,10 +266,7 @@ internal DictionaryEnumerator( MessagePackObjectDictionary dictionary )
 			/// <exception cref="T:System.InvalidOperationException">
 			///		The collection was modified after the enumerator was created. 
 			///	</exception>
-			public bool MoveNext()
-			{
-				return this._underlying.MoveNext();
-			}
+			public bool MoveNext() => this._underlying.MoveNext();
 
 			/// <summary>
 			///		Sets the enumerator to its initial position, which is before the first element in the collection.
@@ -310,10 +274,7 @@ public bool MoveNext()
 			/// <exception cref="T:System.InvalidOperationException">
 			///		The collection was modified after the enumerator was created. 
 			///	</exception>
-			void IEnumerator.Reset()
-			{
-				this._underlying.Reset();
-			}
+			void IEnumerator.Reset() => this._underlying.Reset();
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs b/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs
index 0c7a6d8e6..e69f8c4b7 100644
--- a/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.KeySet.Enumerator.cs
@@ -1,44 +1,21 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 
 namespace MsgPack
 {
-	partial class MessagePackObjectDictionary
+#warning TODO: UNITY KEYSET
+	public partial class MessagePackObjectDictionary
 	{
 #if !UNITY
-		partial class KeySet
+		public partial class KeySet
 #else
-		partial class KeyCollection
+		public partial class KeyCollection
 #endif // UNITY
 		{
 #if !UNITY
@@ -64,10 +41,7 @@ public struct Enumerator : IEnumerator<MessagePackObject>
 				/// <value>
 				///		The element in the underlying collection at the current position of the enumerator.
 				/// </value>
-				public MessagePackObject Current
-				{
-					get { return this._underlying.Current.Key; }
-				}
+				public MessagePackObject Current => this._underlying.Current.Key;
 
 				/// <summary>
 				///		Gets the element at the current position of the enumerator.
@@ -78,14 +52,11 @@ public MessagePackObject Current
 				/// <exception cref="InvalidOperationException">
 				///		The enumerator is positioned before the first element of the collection or after the last element. 
 				/// </exception>
-				object IEnumerator.Current
-				{
-					get { return this._underlying.GetCurrentStrict().Key; }
-				}
+				object IEnumerator.Current => this._underlying.GetCurrentStrict().Key;
 
-				internal Enumerator( MessagePackObjectDictionary dictionary )
+				internal Enumerator(MessagePackObjectDictionary dictionary)
 				{
-					Contract.Assert( dictionary != null, "dictionary != null" );
+					Debug.Assert(dictionary != null, "dictionary != null");
 
 					this._underlying = dictionary.GetEnumerator();
 				}
@@ -93,10 +64,7 @@ internal Enumerator( MessagePackObjectDictionary dictionary )
 				/// <summary>
 				///		Releases all resources used by the this instance.
 				/// </summary>
-				public void Dispose()
-				{
-					this._underlying.Dispose();
-				}
+				public void Dispose() => this._underlying.Dispose();
 
 				/// <summary>
 				///		Advances the enumerator to the next element of the underlying collection.
@@ -120,10 +88,7 @@ public bool MoveNext()
 				/// <exception cref="T:System.InvalidOperationException">
 				///		The collection was modified after the enumerator was created. 
 				///	</exception>
-				void IEnumerator.Reset()
-				{
-					this._underlying.ResetCore();
-				}
+				void IEnumerator.Reset() => this._underlying.ResetCore();
 			}
 		}
 	}
diff --git a/src/MsgPack/MessagePackObjectDictionary.KeySet.cs b/src/MsgPack/MessagePackObjectDictionary.KeySet.cs
index a285eed4b..1deb12e7e 100644
--- a/src/MsgPack/MessagePackObjectDictionary.KeySet.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.KeySet.cs
@@ -1,51 +1,26 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 
 namespace MsgPack
 {
-	partial class MessagePackObjectDictionary
+#warning TODO: READONLY INTERFACES
+#warning TODO: KeySet in Unity
+	public partial class MessagePackObjectDictionary
 	{
 		/// <summary>
 		///		Represents the set of <see cref="MessagePackObjectDictionary"/> keys.
 		/// </summary>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-		[DebuggerDisplay( "Count={Count}" )]
-		[DebuggerTypeProxy( typeof( CollectionDebuggerProxy<> ) )]
-		[SuppressMessage( "Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Justification = "ICollection implementing dictionary should return ICollection implementing values." )]
+		[DebuggerDisplay("Count={Count}")]
+		[DebuggerTypeProxy(typeof(CollectionDebuggerProxy<>))]
+		[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Justification = "ICollection implementing dictionary should return ICollection implementing values.")]
 #if !UNITY
 		public sealed partial class KeySet :
 #if !NET35
@@ -65,33 +40,21 @@ public sealed partial class KeyCollection :
 			/// <returns>
 			///		The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.
 			///   </returns>
-			public int Count
-			{
-				get { return this._dictionary.Count; }
-			}
+			public int Count => this._dictionary.Count;
 
-			bool ICollection<MessagePackObject>.IsReadOnly
-			{
-				get { return true; }
-			}
+			bool ICollection<MessagePackObject>.IsReadOnly => true;
 
-			bool ICollection.IsSynchronized
-			{
-				get { return false; }
-			}
+			bool ICollection.IsSynchronized => false;
 
-			object ICollection.SyncRoot
-			{
-				get { return this; }
-			}
+			object ICollection.SyncRoot => this;
 
 #if !UNITY
-			internal KeySet( MessagePackObjectDictionary dictionary )
+			internal KeySet(MessagePackObjectDictionary dictionary)
 #else
-			internal KeyCollection( MessagePackObjectDictionary dictionary )
+			internal KeyCollection(MessagePackObjectDictionary dictionary)
 #endif // !UNITY
 			{
-				Contract.Assert( dictionary != null, "dictionary != null" );
+				Debug.Assert(dictionary != null, "dictionary != null");
 
 				this._dictionary = dictionary;
 			}
@@ -103,17 +66,8 @@ internal KeyCollection( MessagePackObjectDictionary dictionary )
 			///		The one-dimensional <see cref="Array"/> that is the destination of the elements copied from this dictionary.
 			///		The <see cref="Array"/> must have zero-based indexing.
 			/// </param>
-			public void CopyTo( MessagePackObject[] array )
-			{
-				if ( array == null )
-				{
-					throw new ArgumentNullException( "array" );
-				}
-
-				Contract.EndContractBlock();
-
-				CollectionOperation.CopyTo( this, this.Count, 0, array, 0, this.Count );
-			}
+			public void CopyTo(MessagePackObject[] array)
+				=> CollectionOperation.CopyTo(this, this.Count, 0, array, 0, this.Count);
 
 			/// <summary>
 			///		Copies the entire collection to a compatible one-dimensional array, 
@@ -126,10 +80,8 @@ public void CopyTo( MessagePackObject[] array )
 			/// <param name="arrayIndex">
 			///		The zero-based index in <paramref name="array"/> at which copying begins. 
 			/// </param>
-			public void CopyTo( MessagePackObject[] array, int arrayIndex )
-			{
-				CollectionOperation.CopyTo( this, this.Count, 0, array, arrayIndex, this.Count );
-			}
+			public void CopyTo(MessagePackObject[] array, int arrayIndex)
+				=> CollectionOperation.CopyTo(this, this.Count, 0, array, arrayIndex, this.Count);
 
 			/// <summary>
 			///		Copies a range of elements from this collection to a compatible one-dimensional array, 
@@ -148,47 +100,29 @@ public void CopyTo( MessagePackObject[] array, int arrayIndex )
 			/// <param name="count">
 			///		The number of elements to copy.
 			/// </param>
-			public void CopyTo( int index, MessagePackObject[] array, int arrayIndex, int count )
+			public void CopyTo(int index, MessagePackObject[] array, int arrayIndex, int count)
 			{
-				if ( array == null )
-				{
-					throw new ArgumentNullException( "array" );
-				}
+				Ensure.NotNull(array);
+				Ensure.IsNotNegative(index);
 
-				if ( index < 0 )
+				if (0 < this.Count && this.Count <= index)
 				{
-					throw new ArgumentOutOfRangeException( "index" );
+					throw new ArgumentException("Specified array is too small to complete copy operation.", "array");
 				}
 
-				if ( 0 < this.Count && this.Count <= index )
-				{
-					throw new ArgumentException( "Specified array is too small to complete copy operation.", "array" );
-				}
+				Ensure.IsNotNegative(arrayIndex);
+				Ensure.IsNotNegative(count);
 
-				if ( arrayIndex < 0 )
+				if (array.Length - count <= arrayIndex)
 				{
-					throw new ArgumentOutOfRangeException( "arrayIndex" );
+					throw new ArgumentException("Specified array is too small to complete copy operation.", "array");
 				}
 
-				if ( count < 0 )
-				{
-					throw new ArgumentOutOfRangeException( "count" );
-				}
-
-				if ( array.Length - count <= arrayIndex )
-				{
-					throw new ArgumentException( "Specified array is too small to complete copy operation.", "array" );
-				}
-
-				Contract.EndContractBlock();
-
-				CollectionOperation.CopyTo( this, this.Count, index, array, arrayIndex, count );
+				CollectionOperation.CopyTo(this, this.Count, index, array, arrayIndex, count);
 			}
 
-			void ICollection.CopyTo( Array array, int arrayIndex )
-			{
-				CollectionOperation.CopyTo( this, this.Count, array, arrayIndex );
-			}
+			void ICollection.CopyTo(Array array, int arrayIndex)
+				=> CollectionOperation.CopyTo(this, this.Count, array, arrayIndex);
 
 			/// <summary>
 			///		Determines whether this collection contains a specific value.
@@ -198,42 +132,25 @@ void ICollection.CopyTo( Array array, int arrayIndex )
 			/// <returns>
 			///		<c>true</c> if <paramref name="item"/> is found in this collection; otherwise, <c>false</c>.
 			/// </returns>
-			bool ICollection<MessagePackObject>.Contains( MessagePackObject item )
-			{
-				return this._dictionary.ContainsKey( item );
-			}
+			bool ICollection<MessagePackObject>.Contains(MessagePackObject item)
+				=> this._dictionary.ContainsKey(item);
 
-			void ICollection<MessagePackObject>.Add( MessagePackObject item )
-			{
-				throw new NotSupportedException();
-			}
+			void ICollection<MessagePackObject>.Add(MessagePackObject item)
+				=> throw new NotSupportedException();
 
 			void ICollection<MessagePackObject>.Clear()
-			{
-				throw new NotSupportedException();
-			}
+				=> throw new NotSupportedException();
 
-			bool ICollection<MessagePackObject>.Remove( MessagePackObject item )
-			{
-				throw new NotSupportedException();
-			}
+			bool ICollection<MessagePackObject>.Remove(MessagePackObject item)
+				=> throw new NotSupportedException();
 
 #if !UNITY
 #if !NET35
-			bool ISet<MessagePackObject>.Add( MessagePackObject item )
-			{
-				throw new NotSupportedException();
-			}
+			bool ISet<MessagePackObject>.Add(MessagePackObject item) => throw new NotSupportedException();
 
-			void ISet<MessagePackObject>.ExceptWith( IEnumerable<MessagePackObject> other )
-			{
-				throw new NotSupportedException();
-			}
+			void ISet<MessagePackObject>.ExceptWith(IEnumerable<MessagePackObject> other) => throw new NotSupportedException();
 
-			void ISet<MessagePackObject>.IntersectWith( IEnumerable<MessagePackObject> other )
-			{
-				throw new NotSupportedException();
-			}
+			void ISet<MessagePackObject>.IntersectWith(IEnumerable<MessagePackObject> other) => throw new NotSupportedException();
 #endif // !NET35
 
 			/// <summary>
@@ -248,10 +165,8 @@ void ISet<MessagePackObject>.IntersectWith( IEnumerable<MessagePackObject> other
 			/// <exception cref="ArgumentNullException">
 			///		<paramref name="other"/> is Nothing.
 			/// </exception>
-			public bool IsProperSubsetOf( IEnumerable<MessagePackObject> other )
-			{
-				return SetOperation.IsProperSubsetOf( this, other );
-			}
+			public bool IsProperSubsetOf(IEnumerable<MessagePackObject> other)
+				=> SetOperation.IsProperSubsetOf(this, other);
 
 			/// <summary>
 			///		Determines whether this set is proper superset of the specified collection.
@@ -265,10 +180,8 @@ public bool IsProperSubsetOf( IEnumerable<MessagePackObject> other )
 			/// <exception cref="ArgumentNullException">
 			///		<paramref name="other"/> is Nothing.
 			/// </exception>
-			public bool IsProperSupersetOf( IEnumerable<MessagePackObject> other )
-			{
-				return SetOperation.IsProperSupersetOf( this, other );
-			}
+			public bool IsProperSupersetOf(IEnumerable<MessagePackObject> other)
+				=> SetOperation.IsProperSupersetOf(this, other);
 
 			/// <summary>
 			///		Determines whether this set is subset of the specified collection.
@@ -282,10 +195,8 @@ public bool IsProperSupersetOf( IEnumerable<MessagePackObject> other )
 			/// <exception cref="ArgumentNullException">
 			///		<paramref name="other"/> is Nothing.
 			/// </exception>
-			public bool IsSubsetOf( IEnumerable<MessagePackObject> other )
-			{
-				return SetOperation.IsSubsetOf( this, other );
-			}
+			public bool IsSubsetOf(IEnumerable<MessagePackObject> other)
+				=> SetOperation.IsSubsetOf(this, other);
 
 			/// <summary>
 			///		Determines whether this set is superset of the specified collection.
@@ -299,10 +210,8 @@ public bool IsSubsetOf( IEnumerable<MessagePackObject> other )
 			/// <exception cref="ArgumentNullException">
 			///		<paramref name="other"/> is Nothing.
 			/// </exception>
-			public bool IsSupersetOf( IEnumerable<MessagePackObject> other )
-			{
-				return SetOperation.IsSupersetOf( this, other );
-			}
+			public bool IsSupersetOf(IEnumerable<MessagePackObject> other)
+				=> SetOperation.IsSupersetOf(this, other);
 
 			/// <summary>
 			///		Determines whether the current set and a specified collection share common elements. 
@@ -316,10 +225,8 @@ public bool IsSupersetOf( IEnumerable<MessagePackObject> other )
 			/// <exception cref="ArgumentNullException">
 			///		<paramref name="other"/> is Nothing.
 			/// </exception>
-			public bool Overlaps( IEnumerable<MessagePackObject> other )
-			{
-				return SetOperation.Overlaps( this, other );
-			}
+			public bool Overlaps(IEnumerable<MessagePackObject> other)
+				=> SetOperation.Overlaps(this, other);
 
 			/// <summary>
 			///		Determines whether this set and the specified collection contain the same elements. 
@@ -333,21 +240,16 @@ public bool Overlaps( IEnumerable<MessagePackObject> other )
 			/// <exception cref="ArgumentNullException">
 			///		<paramref name="other"/> is Nothing.
 			/// </exception>
-			public bool SetEquals( IEnumerable<MessagePackObject> other )
-			{
-				return SetOperation.SetEquals( this, other );
-			}
+			public bool SetEquals(IEnumerable<MessagePackObject> other)
+				=> SetOperation.SetEquals(this, other);
 
 #if !NET35
-			void ISet<MessagePackObject>.SymmetricExceptWith( IEnumerable<MessagePackObject> other )
-			{
-				throw new NotSupportedException();
-			}
+			void ISet<MessagePackObject>.SymmetricExceptWith(IEnumerable<MessagePackObject> other)
+				=> throw new NotSupportedException();
+
+			void ISet<MessagePackObject>.UnionWith(IEnumerable<MessagePackObject> other)
+				=> throw new NotSupportedException();
 
-			void ISet<MessagePackObject>.UnionWith( IEnumerable<MessagePackObject> other )
-			{
-				throw new NotSupportedException();
-			}
 #endif // !NET35
 #endif // !UNITY
 
@@ -357,20 +259,11 @@ void ISet<MessagePackObject>.UnionWith( IEnumerable<MessagePackObject> other )
 			/// <returns>
 			///		Returns an enumerator that iterates through this collction.
 			/// </returns>
-			public Enumerator GetEnumerator()
-			{
-				return new Enumerator( this._dictionary );
-			}
+			public Enumerator GetEnumerator() => new Enumerator(this._dictionary);
 
-			IEnumerator<MessagePackObject> IEnumerable<MessagePackObject>.GetEnumerator()
-			{
-				return this.GetEnumerator();
-			}
+			IEnumerator<MessagePackObject> IEnumerable<MessagePackObject>.GetEnumerator() => this.GetEnumerator();
 
-			IEnumerator IEnumerable.GetEnumerator()
-			{
-				return this.GetEnumerator();
-			}
+			IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 		}
 	}
 }
diff --git a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs
index 47f9dd0ff..a2fa3dc1c 100644
--- a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.Enumerator.cs
@@ -1,41 +1,17 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 
 namespace MsgPack
 {
-	partial class MessagePackObjectDictionary
+	public partial class MessagePackObjectDictionary
 	{
-		partial class ValueCollection
+		public partial class ValueCollection
 		{
 			/// <summary>
 			///		Enumerates the elements of a <see cref="MessagePackObjectDictionary.ValueCollection"/>.
@@ -53,10 +29,7 @@ public struct Enumerator : IEnumerator<MessagePackObject>
 				/// <value>
 				///		The element in the underlying collection at the current position of the enumerator.
 				/// </value>
-				public MessagePackObject Current
-				{
-					get { return this._underlying.Current.Value; }
-				}
+				public MessagePackObject Current => this._underlying.Current.Value;
 
 				/// <summary>
 				///		Gets the element at the current position of the enumerator.
@@ -67,14 +40,11 @@ public MessagePackObject Current
 				/// <exception cref="InvalidOperationException">
 				///		The enumerator is positioned before the first element of the collection or after the last element. 
 				/// </exception>
-				object IEnumerator.Current
-				{
-					get { return this._underlying.GetCurrentStrict().Value; }
-				}
+				object IEnumerator.Current => this._underlying.GetCurrentStrict().Value;
 
-				internal Enumerator( MessagePackObjectDictionary dictionary )
+				internal Enumerator(MessagePackObjectDictionary dictionary)
 				{
-					Contract.Assert( dictionary != null, "dictionary != null" );
+					Debug.Assert(dictionary != null, "dictionary != null");
 
 					this._underlying = dictionary.GetEnumerator();
 				}
@@ -82,10 +52,7 @@ internal Enumerator( MessagePackObjectDictionary dictionary )
 				/// <summary>
 				///		Releases all resources used by the this instance.
 				/// </summary>
-				public void Dispose()
-				{
-					this._underlying.Dispose();
-				}
+				public void Dispose() => this._underlying.Dispose();
 
 				/// <summary>
 				///		Advances the enumerator to the next element of the underlying collection.
@@ -109,11 +76,8 @@ public bool MoveNext()
 				/// <exception cref="T:System.InvalidOperationException">
 				///		The collection was modified after the enumerator was created. 
 				///	</exception>
-				void IEnumerator.Reset()
-				{
-					this._underlying.ResetCore();
-				}
+				void IEnumerator.Reset() => this._underlying.ResetCore();
 			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs
index a2db23d50..134c3359b 100644
--- a/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.ValueCollection.cs
@@ -1,51 +1,24 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 
 namespace MsgPack
 {
-	partial class MessagePackObjectDictionary
+	public partial class MessagePackObjectDictionary
 	{
 		/// <summary>
 		///		Represents the collection of values in a <see cref="MessagePackObjectDictionary"/>.
 		/// </summary>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-		[DebuggerDisplay( "Count={Count}" )]
-		[DebuggerTypeProxy( typeof( CollectionDebuggerProxy<> ) )]
-		[SuppressMessage( "Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Justification = "ICollection implementing dictionary should return ICollection implementing values." )]
+		[DebuggerDisplay("Count={Count}")]
+		[DebuggerTypeProxy(typeof(CollectionDebuggerProxy<>))]
+		[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Justification = "ICollection implementing dictionary should return ICollection implementing values.")]
 		public sealed partial class ValueCollection : ICollection<MessagePackObject>, ICollection
 		{
 			private readonly MessagePackObjectDictionary _dictionary;
@@ -56,29 +29,17 @@ public sealed partial class ValueCollection : ICollection<MessagePackObject>, IC
 			/// <returns>
 			///		The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.
 			///   </returns>
-			public int Count
-			{
-				get { return this._dictionary.Count; }
-			}
+			public int Count => this._dictionary.Count;
 
-			bool ICollection<MessagePackObject>.IsReadOnly
-			{
-				get { return true; }
-			}
+			bool ICollection<MessagePackObject>.IsReadOnly => true;
 
-			bool ICollection.IsSynchronized
-			{
-				get { return false; }
-			}
+			bool ICollection.IsSynchronized => false;
 
-			object ICollection.SyncRoot
-			{
-				get { return this; }
-			}
+			object ICollection.SyncRoot => this;
 
-			internal ValueCollection( MessagePackObjectDictionary dictionary )
+			internal ValueCollection(MessagePackObjectDictionary dictionary)
 			{
-				Contract.Assert( dictionary != null, "dictionary != null" );
+				Debug.Assert(dictionary != null, "dictionary != null");
 
 				this._dictionary = dictionary;
 			}
@@ -90,17 +51,8 @@ internal ValueCollection( MessagePackObjectDictionary dictionary )
 			///		The one-dimensional <see cref="Array"/> that is the destination of the elements copied from this dictionary.
 			///		The <see cref="Array"/> must have zero-based indexing.
 			/// </param>
-			public void CopyTo( MessagePackObject[] array )
-			{
-				if ( array == null )
-				{
-					throw new ArgumentNullException( "array" );
-				}
-
-				Contract.EndContractBlock();
-
-				CollectionOperation.CopyTo( this, this.Count, 0, array, 0, this.Count );
-			}
+			public void CopyTo(MessagePackObject[] array)
+				=> CollectionOperation.CopyTo(this, this.Count, 0, array, 0, this.Count);
 
 			/// <summary>
 			///		Copies the entire collection to a compatible one-dimensional array, 
@@ -113,10 +65,8 @@ public void CopyTo( MessagePackObject[] array )
 			/// <param name="arrayIndex">
 			///		The zero-based index in <paramref name="array"/> at which copying begins. 
 			/// </param>
-			public void CopyTo( MessagePackObject[] array, int arrayIndex )
-			{
-				CollectionOperation.CopyTo( this, this.Count, 0, array, arrayIndex, this.Count );
-			}
+			public void CopyTo(MessagePackObject[] array, int arrayIndex)
+				=> CollectionOperation.CopyTo(this, this.Count, 0, array, arrayIndex, this.Count);
 
 			/// <summary>
 			///		Copies a range of elements from this collection to a compatible one-dimensional array, 
@@ -135,47 +85,29 @@ public void CopyTo( MessagePackObject[] array, int arrayIndex )
 			/// <param name="count">
 			///		The number of elements to copy.
 			/// </param>
-			public void CopyTo( int index, MessagePackObject[] array, int arrayIndex, int count )
+			public void CopyTo(int index, MessagePackObject[] array, int arrayIndex, int count)
 			{
-				if ( array == null )
-				{
-					throw new ArgumentNullException( "array" );
-				}
+				Ensure.NotNull(array);
+				Ensure.IsNotNegative(index);
 
-				if ( index < 0 )
+				if (0 < this.Count && this.Count <= index)
 				{
-					throw new ArgumentOutOfRangeException( "index" );
+					throw new ArgumentException("Specified array is too small to complete copy operation.", "array");
 				}
 
-				if ( 0 < this.Count && this.Count <= index )
-				{
-					throw new ArgumentException( "Specified array is too small to complete copy operation.", "array" );
-				}
+				Ensure.IsNotNegative(arrayIndex);
+				Ensure.IsNotNegative(count);
 
-				if ( arrayIndex < 0 )
+				if (array.Length - count <= arrayIndex)
 				{
-					throw new ArgumentOutOfRangeException( "arrayIndex" );
+					throw new ArgumentException("Specified array is too small to complete copy operation.", "array");
 				}
 
-				if ( count < 0 )
-				{
-					throw new ArgumentOutOfRangeException( "count" );
-				}
-
-				if ( array.Length - count <= arrayIndex )
-				{
-					throw new ArgumentException( "Specified array is too small to complete copy operation.", "array" );
-				}
-
-				Contract.EndContractBlock();
-
-				CollectionOperation.CopyTo( this, this.Count, index, array, arrayIndex, count );
+				CollectionOperation.CopyTo(this, this.Count, index, array, arrayIndex, count);
 			}
 
-			void ICollection.CopyTo( Array array, int arrayIndex )
-			{
-				CollectionOperation.CopyTo( this, this.Count, array, arrayIndex );
-			}
+			void ICollection.CopyTo(Array array, int arrayIndex)
+				=> CollectionOperation.CopyTo(this, this.Count, array, arrayIndex);
 
 			/// <summary>
 			///		Determines whether this collection contains a specific value.
@@ -185,25 +117,17 @@ void ICollection.CopyTo( Array array, int arrayIndex )
 			/// <returns>
 			///		<c>true</c> if <paramref name="item"/> is found in this collection; otherwise, <c>false</c>.
 			/// </returns>
-			bool ICollection<MessagePackObject>.Contains( MessagePackObject item )
-			{
-				return this._dictionary.ContainsValue( item );
-			}
+			bool ICollection<MessagePackObject>.Contains(MessagePackObject item)
+				=> this._dictionary.ContainsValue(item);
 
-			void ICollection<MessagePackObject>.Add( MessagePackObject item )
-			{
-				throw new NotSupportedException();
-			}
+			void ICollection<MessagePackObject>.Add(MessagePackObject item)
+				=> throw new NotSupportedException();
 
 			void ICollection<MessagePackObject>.Clear()
-			{
-				throw new NotSupportedException();
-			}
+				=> throw new NotSupportedException();
 
-			bool ICollection<MessagePackObject>.Remove( MessagePackObject item )
-			{
-				throw new NotSupportedException();
-			}
+			bool ICollection<MessagePackObject>.Remove(MessagePackObject item)
+				=> throw new NotSupportedException();
 
 			/// <summary>
 			///		Returns an enumerator that iterates through this collction.
@@ -211,20 +135,12 @@ bool ICollection<MessagePackObject>.Remove( MessagePackObject item )
 			/// <returns>
 			///		Returns an enumerator that iterates through this collction.
 			/// </returns>
-			public Enumerator GetEnumerator()
-			{
-				return new Enumerator( this._dictionary );
-			}
+			public Enumerator GetEnumerator() => new Enumerator(this._dictionary);
 
 			IEnumerator<MessagePackObject> IEnumerable<MessagePackObject>.GetEnumerator()
-			{
-				return this.GetEnumerator();
-			}
+				=> this.GetEnumerator();
 
-			IEnumerator IEnumerable.GetEnumerator()
-			{
-				return this.GetEnumerator();
-			}
+			IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/MessagePackObjectDictionary.cs b/src/MsgPack/MessagePackObjectDictionary.cs
index b1570b301..3dec8140f 100644
--- a/src/MsgPack/MessagePackObjectDictionary.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.cs
@@ -1,37 +1,12 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 using System.Globalization;
 using System.Linq;
 #if FEATURE_BINARY_SERIALIZATION
@@ -54,14 +29,15 @@ namespace MsgPack
 	[DebuggerTypeProxy( typeof( DictionaryDebuggerProxy<,> ) )]
 	public partial class MessagePackObjectDictionary :
 		IDictionary<MessagePackObject, MessagePackObject>, IDictionary
+#warning TODO: ReadOnlyInterface
 	{
 		private const int Threashold = 10;
 		private const int ListInitialCapacity = Threashold;
 		private const int DictionaryInitialCapacity = Threashold * 2;
 
-		private List<MessagePackObject> _keys;
-		private List<MessagePackObject> _values;
-		private Dictionary<MessagePackObject, MessagePackObject> _dictionary;
+		private List<MessagePackObject>? _keys;
+		private List<MessagePackObject>? _values;
+		private Dictionary<MessagePackObject, MessagePackObject>? _dictionary;
 		private int _version;
 
 		private bool _isFrozen;
@@ -75,10 +51,7 @@ public partial class MessagePackObjectDictionary :
 		/// <remarks>
 		///		This operation is an O(1) operation.
 		/// </remarks>
-		public bool IsFrozen
-		{
-			get { return this._isFrozen; }
-		}
+		public bool IsFrozen => this._isFrozen;
 
 		/// <summary>
 		///		Gets the number of elements contained in the <see cref="MessagePackObjectDictionary"/>.
@@ -94,7 +67,7 @@ public int Count
 			get
 			{
 				this.AssertInvariant();
-				return this._dictionary == null ? this._keys.Count : this._dictionary.Count;
+				return this._dictionary == null ? this._keys!.Count : this._dictionary.Count;
 			}
 		}
 
@@ -123,37 +96,34 @@ public int Count
 		///			This method approaches an O(1) operation.
 		///		</para>
 		///	</remarks>
-		public MessagePackObject this[ MessagePackObject key ]
+		public MessagePackObject this[MessagePackObject key]
 		{
 			get
 			{
-				if ( key.IsNil )
+				if (key.IsNil)
 				{
-					ThrowKeyNotNilException( "key" );
+					ThrowKeyNotNilException("key");
 				}
 
-				Contract.EndContractBlock();
-
 				MessagePackObject result;
-				if ( !this.TryGetValue( key, out result ) )
+				if (!this.TryGetValue(key, out result))
 				{
-					throw new KeyNotFoundException( String.Format( CultureInfo.CurrentCulture, "Key '{0}'({1} type) does not exist in this dictionary.", key, key.UnderlyingType ) );
+					throw new KeyNotFoundException(String.Format(CultureInfo.CurrentCulture, "Key '{0}'({1} type) does not exist in this dictionary.", key, key.UnderlyingType));
 				}
 
 				return result;
 			}
 			set
 			{
-				if ( key.IsNil )
+				if (key.IsNil)
 				{
-					ThrowKeyNotNilException( "key" );
+					ThrowKeyNotNilException("key");
 				}
 
 				this.VerifyIsNotFrozen();
 
-				Contract.EndContractBlock();
 				this.AssertInvariant();
-				this.AddCore( key, value, true );
+				this.AddCore(key, value, true);
 			}
 		}
 
@@ -173,7 +143,7 @@ public KeySet Keys
 			get
 			{
 				this.AssertInvariant();
-				return new KeySet( this );
+				return new KeySet(this);
 			}
 		}
 #else
@@ -212,68 +182,43 @@ public ValueCollection Values
 			get
 			{
 				this.AssertInvariant();
-				return new ValueCollection( this );
+				return new ValueCollection(this);
 			}
 		}
 
-		ICollection<MessagePackObject> IDictionary<MessagePackObject, MessagePackObject>.Keys
-		{
-			get { return this.Keys; }
-		}
+		ICollection<MessagePackObject> IDictionary<MessagePackObject, MessagePackObject>.Keys => this.Keys;
 
-		ICollection<MessagePackObject> IDictionary<MessagePackObject, MessagePackObject>.Values
-		{
-			get { return this.Values; }
-		}
+		ICollection<MessagePackObject> IDictionary<MessagePackObject, MessagePackObject>.Values => this.Values;
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.IsReadOnly
-		{
-			get { return this.IsFrozen; }
-		}
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.IsReadOnly => this.IsFrozen;
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		bool IDictionary.IsFixedSize
-		{
-			get { return this.IsFrozen; }
-		}
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		bool IDictionary.IsFixedSize => this.IsFrozen;
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		bool IDictionary.IsReadOnly
-		{
-			get { return this.IsFrozen; }
-		}
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		bool IDictionary.IsReadOnly => this.IsFrozen;
 
-		ICollection IDictionary.Keys
-		{
-			get { return this._keys; }
-		}
+#warning TODO: NRE
+		ICollection IDictionary.Keys => this._keys;
 
-		ICollection IDictionary.Values
-		{
-			get { return this.Values; }
-		}
+		ICollection IDictionary.Values => this.Values;
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		object IDictionary.this[ object key ]
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		object? IDictionary.this[object key]
 		{
 			get
 			{
-				if ( key == null )
-				{
-					throw new ArgumentNullException( "key" );
-				}
-
-				Contract.EndContractBlock();
+				Ensure.NotNull(key);
 
-				var typedKey = ValidateObjectArgument( key, "key" );
-				if ( typedKey.IsNil )
+				var typedKey = ValidateObjectArgument(key);
+				if (typedKey.IsNil)
 				{
-					ThrowKeyNotNilException( "key" );
+					ThrowKeyNotNilException("key");
 				}
 
 				MessagePackObject value;
-				if ( !this.TryGetValue( typedKey, out value ) )
+				if (!this.TryGetValue(typedKey, out value))
 				{
 					return null;
 				}
@@ -282,36 +227,25 @@ object IDictionary.this[ object key ]
 			}
 			set
 			{
-				if ( key == null )
-				{
-					throw new ArgumentNullException( "key" );
-				}
+				Ensure.NotNull(key);
 
 				this.VerifyIsNotFrozen();
 
-				Contract.EndContractBlock();
-
-				var typedKey = ValidateObjectArgument( key, "key" );
-				if ( typedKey.IsNil )
+				var typedKey = ValidateObjectArgument(key);
+				if (typedKey.IsNil)
 				{
-					ThrowKeyNotNilException( "key" );
+					ThrowKeyNotNilException("key");
 				}
 
-				this[ typedKey ] = ValidateObjectArgument( value, "value" );
+				this[typedKey] = ValidateObjectArgument(value, "value");
 			}
 		}
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		bool ICollection.IsSynchronized
-		{
-			get { return false; }
-		}
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		bool ICollection.IsSynchronized => false;
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		object ICollection.SyncRoot
-		{
-			get { return this; }
-		}
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		object ICollection.SyncRoot => this;
 
 		/// <summary>
 		/// Initializes an empty new instance of the <see cref="MessagePackObjectDictionary"/> class with default capacity.
@@ -321,8 +255,8 @@ object ICollection.SyncRoot
 		/// </remarks>
 		public MessagePackObjectDictionary()
 		{
-			this._keys = new List<MessagePackObject>( ListInitialCapacity );
-			this._values = new List<MessagePackObject>( ListInitialCapacity );
+			this._keys = new List<MessagePackObject>(ListInitialCapacity);
+			this._values = new List<MessagePackObject>(ListInitialCapacity);
 		}
 
 		/// <summary>
@@ -335,23 +269,18 @@ public MessagePackObjectDictionary()
 		/// <remarks>
 		///		This operation is an O(1) operation.
 		/// </remarks>
-		public MessagePackObjectDictionary( int initialCapacity )
+		public MessagePackObjectDictionary(int initialCapacity)
 		{
-			if ( initialCapacity < 0 )
-			{
-				throw new ArgumentOutOfRangeException( "initialCapacity" );
-			}
-
-			Contract.EndContractBlock();
+			Ensure.IsNotLessThan(initialCapacity, 0);
 
-			if ( initialCapacity <= Threashold )
+			if (initialCapacity <= Threashold)
 			{
-				this._keys = new List<MessagePackObject>( initialCapacity );
-				this._values = new List<MessagePackObject>( initialCapacity );
+				this._keys = new List<MessagePackObject>(initialCapacity);
+				this._values = new List<MessagePackObject>(initialCapacity);
 			}
 			else
 			{
-				this._dictionary = new Dictionary<MessagePackObject, MessagePackObject>( initialCapacity, MessagePackObjectEqualityComparer.Instance );
+				this._dictionary = new Dictionary<MessagePackObject, MessagePackObject>(initialCapacity, MessagePackObjectEqualityComparer.Instance);
 			}
 		}
 
@@ -369,138 +298,126 @@ public MessagePackObjectDictionary( int initialCapacity )
 		///		This constructor takes <em>O(N)</em> time, <em>N</em> is <see cref="P:ICollection{T}.Count"/> of <paramref name="dictionary"/>.
 		///		Initial capacity will be <see cref="P:ICollection{T}.Count"/> of <paramref name="dictionary"/>.
 		/// </remarks>
-		public MessagePackObjectDictionary( IDictionary<MessagePackObject, MessagePackObject> dictionary )
+		public MessagePackObjectDictionary(IDictionary<MessagePackObject, MessagePackObject> dictionary)
 		{
-			if ( dictionary == null )
-			{
-				throw new ArgumentNullException( "dictionary" );
-			}
-
-			Contract.EndContractBlock();
+			Ensure.NotNull(dictionary);
 
-			if ( dictionary.Count <= Threashold )
+			if (dictionary.Count <= Threashold)
 			{
-				this._keys = new List<MessagePackObject>( dictionary.Count );
-				this._values = new List<MessagePackObject>( dictionary.Count );
+				this._keys = new List<MessagePackObject>(dictionary.Count);
+				this._values = new List<MessagePackObject>(dictionary.Count);
 			}
 			else
 			{
-				this._dictionary = new Dictionary<MessagePackObject, MessagePackObject>( dictionary.Count, MessagePackObjectEqualityComparer.Instance );
+				this._dictionary = new Dictionary<MessagePackObject, MessagePackObject>(dictionary.Count, MessagePackObjectEqualityComparer.Instance);
 			}
 
 			try
 			{
-				foreach ( var kv in dictionary )
+				foreach (var kv in dictionary)
 				{
-					this.AddCore( kv.Key, kv.Value, false );
+					this.AddCore(kv.Key, kv.Value, false);
 				}
 			}
-			catch ( ArgumentException ex )
+			catch (ArgumentException ex)
 			{
 #if SILVERLIGHT
 				throw new ArgumentException( "Failed to copy specified dictionary.", ex );
 #else
-				throw new ArgumentException( "Failed to copy specified dictionary.", "dictionary", ex );
+				throw new ArgumentException("Failed to copy specified dictionary.", "dictionary", ex);
 #endif
 			}
 		}
 
-		private static void ThrowKeyNotNilException( string parameterName )
+		private static void ThrowKeyNotNilException(string parameterName)
 		{
-			throw new ArgumentNullException( parameterName, "Key cannot be nil." );
+			throw new ArgumentNullException(parameterName, "Key cannot be nil.");
 		}
 
-		private static void ThrowDuplicatedKeyException( MessagePackObject key, string parameterName )
+		private static void ThrowDuplicatedKeyException(MessagePackObject key, string parameterName)
 		{
-			throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, "Key '{0}'({1} type) already exists in this dictionary.", key, key.UnderlyingType ), parameterName );
+			throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "Key '{0}'({1} type) already exists in this dictionary.", key, key.UnderlyingType), parameterName);
 		}
 
 		private void VerifyIsNotFrozen()
 		{
-			if ( this._isFrozen )
+			if (this._isFrozen)
 			{
-				throw new InvalidOperationException( "This dictionary is frozen." );
+				throw new InvalidOperationException("This dictionary is frozen.");
 			}
 		}
 
-		[Conditional( "DEBUG" )]
+		[Conditional("DEBUG")]
 		private void AssertInvariant()
 		{
-			if ( this._dictionary == null )
+			if (this._dictionary == null)
 			{
-				Contract.Assert( this._keys != null, "this._keys != null" );
-				Contract.Assert( this._values != null, "this._values != null" );
-				Contract.Assert( this._keys.Count == this._values.Count, "this._keys.Count == this._values.Count" );
-				Contract.Assert(
-					this._keys.Distinct( MessagePackObjectEqualityComparer.Instance ).Count() == this._keys.Count,
+				Debug.Assert(this._keys != null, "this._keys != null");
+				Debug.Assert(this._values != null, "this._values != null");
+				Debug.Assert(this._keys.Count == this._values.Count, "this._keys.Count == this._values.Count");
+				Debug.Assert(
+					this._keys.Distinct(MessagePackObjectEqualityComparer.Instance).Count() == this._keys.Count,
 					"this._keys.Distinct( MessagePackObjectEqualityComparer.Instance ).Count() == this._keys.Count"
 				);
 			}
 			else
 			{
-				Contract.Assert( this._keys == null, "this._keys == null" );
-				Contract.Assert( this._values == null, "this._values == null" );
+				Debug.Assert(this._keys == null, "this._keys == null");
+				Debug.Assert(this._values == null, "this._values == null");
 			}
 		}
 
-		private static MessagePackObject ValidateObjectArgument( object obj, string parameterName )
+		private static MessagePackObject ValidateObjectArgument(object? obj, [CallerArgumentExpression("obj")]string parameterName = null!)
 		{
-			var result = TryValidateObjectArgument( obj );
-			if ( result == null )
+			var result = TryValidateObjectArgument(obj);
+			if (result == null)
 			{
-				throw new ArgumentException( String.Format( CultureInfo.CurrentCulture, "Cannot convert '{1}' to {0}.", typeof( MessagePackObject ).Name, obj.GetType() ), parameterName );
+				throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "Cannot convert '{1}' to {0}.", typeof(MessagePackObject).Name, obj.GetType()), parameterName);
 			}
 
 			return result.Value;
 		}
 
-		private static MessagePackObject? TryValidateObjectArgument( object value )
+		private static MessagePackObject? TryValidateObjectArgument(object? value)
 		{
-			if ( value == null )
+			if (value == null)
 			{
 				return MessagePackObject.Nil;
 			}
 
-			if ( value is MessagePackObject )
+			if (value is MessagePackObject)
 			{
-				return ( MessagePackObject )value;
+				return (MessagePackObject)value;
 			}
 
-			byte[] asBytes;
-			if ( ( asBytes = value as byte[] ) != null )
+			if (value is byte[] asBytes)
 			{
 				return asBytes;
 			}
 
-			string asString;
-			if ( ( asString = value as string ) != null )
+			if (value is string asString)
 			{
 				return asString;
 			}
 
-			MessagePackString asMessagePackString;
-			if ( ( asMessagePackString = value as MessagePackString ) != null )
+			if (value is MessagePackString asMessagePackString)
 			{
-				return new MessagePackObject( asMessagePackString );
+				return new MessagePackObject(asMessagePackString);
 			}
 
-#if ( NETSTANDARD1_1 || NETSTANDARD1_3 )
-			switch ( NetStandardCompatibility.GetTypeCode( value.GetType() ) )
-#else
-			switch ( Type.GetTypeCode( value.GetType() ) )
-#endif // NETSTANDARD1_1 || NETSTANDARD1_3
+			switch (Type.GetTypeCode(value.GetType()))
 			{
 				case TypeCode.Boolean:
 				{
-					return ( bool )value;
+					return (bool)value;
 				}
 				case TypeCode.Byte:
 				{
-					return ( byte )value;
+					return (byte)value;
 				}
 				case TypeCode.DateTime:
 				{
-					return MessagePackConvert.FromDateTime( ( DateTime )value );
+					return MessagePackConvert.FromDateTime((DateTime)value);
 				}
 				case TypeCode.DBNull:
 				case TypeCode.Empty:
@@ -509,27 +426,27 @@ private static MessagePackObject ValidateObjectArgument( object obj, string para
 				}
 				case TypeCode.Double:
 				{
-					return ( double )value;
+					return (double)value;
 				}
 				case TypeCode.Int16:
 				{
-					return ( short )value;
+					return (short)value;
 				}
 				case TypeCode.Int32:
 				{
-					return ( int )value;
+					return (int)value;
 				}
 				case TypeCode.Int64:
 				{
-					return ( long )value;
+					return (long)value;
 				}
 				case TypeCode.SByte:
 				{
-					return ( sbyte )value;
+					return (sbyte)value;
 				}
 				case TypeCode.Single:
 				{
-					return ( float )value;
+					return (float)value;
 				}
 				case TypeCode.String:
 				{
@@ -537,15 +454,15 @@ private static MessagePackObject ValidateObjectArgument( object obj, string para
 				}
 				case TypeCode.UInt16:
 				{
-					return ( ushort )value;
+					return (ushort)value;
 				}
 				case TypeCode.UInt32:
 				{
-					return ( uint )value;
+					return (uint)value;
 				}
 				case TypeCode.UInt64:
 				{
-					return ( ulong )value;
+					return (ulong)value;
 				}
 				// ReSharper disable RedundantCaseLabel
 				case TypeCode.Char:
@@ -572,20 +489,19 @@ private static MessagePackObject ValidateObjectArgument( object obj, string para
 		/// <remarks>
 		///		This method approaches an O(1) operation.
 		/// </remarks>
-		public bool ContainsKey( MessagePackObject key )
+		public bool ContainsKey(MessagePackObject key)
 		{
-			if ( key.IsNil )
+			if (key.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
-			Contract.EndContractBlock();
 			this.AssertInvariant();
 
 			return
 				this._dictionary == null
-				? this._keys.Contains( key, MessagePackObjectEqualityComparer.Instance )
-				: this._dictionary.ContainsKey( key );
+				? this._keys.Contains(key, MessagePackObjectEqualityComparer.Instance)
+				: this._dictionary.ContainsKey(key);
 		}
 
 		/// <summary>
@@ -598,21 +514,21 @@ public bool ContainsKey( MessagePackObject key )
 		/// <remarks>
 		///		This method approaches an O(<em>N</em>) operation where <em>N</em> is <see cref="Count"/>.
 		/// </remarks>
-		public bool ContainsValue( MessagePackObject value )
+		public bool ContainsValue(MessagePackObject value)
 		{
 			this.AssertInvariant();
 
 			return
-				this._dictionary == null 
-				? this._values.Contains( value, MessagePackObjectEqualityComparer.Instance )
-				: this._dictionary.ContainsValue( value );
+				this._dictionary == null
+				? this._values.Contains(value, MessagePackObjectEqualityComparer.Instance)
+				: this._dictionary.ContainsValue(value);
 		}
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Contains( KeyValuePair<MessagePackObject, MessagePackObject> item )
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Contains(KeyValuePair<MessagePackObject, MessagePackObject> item)
 		{
 			MessagePackObject value;
-			if ( !this.TryGetValue( item.Key, out value ) )
+			if (!this.TryGetValue(item.Key, out value))
 			{
 				return false;
 			}
@@ -620,25 +536,25 @@ bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Contains( K
 			return item.Value == value;
 		}
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		bool IDictionary.Contains( object key )
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		bool IDictionary.Contains(object key)
 		{
 			// ReSharper disable HeuristicUnreachableCode
 			// ReSharper disable once ConditionIsAlwaysTrueOrFalse
-			if ( key == null )
+			if (key == null)
 			{
 				return false;
 			}
 			// ReSharper restore HeuristicUnreachableCode
 
-			var typedKey = TryValidateObjectArgument( key );
+			var typedKey = TryValidateObjectArgument(key);
 
-			if ( typedKey.GetValueOrDefault().IsNil )
+			if (typedKey.GetValueOrDefault().IsNil)
 			{
 				return false;
 			}
 			{
-				return this.ContainsKey( typedKey.GetValueOrDefault() );
+				return this.ContainsKey(typedKey.GetValueOrDefault());
 			}
 		}
 
@@ -668,33 +584,35 @@ bool IDictionary.Contains( object key )
 		///			This method approaches an O(1) operation.
 		///		</para>
 		///	</remarks>
-		public bool TryGetValue( MessagePackObject key, out MessagePackObject value )
+		public bool TryGetValue(MessagePackObject key, out MessagePackObject value)
 		{
-			if ( key.IsNil )
+			if (key.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
-			Contract.EndContractBlock();
 			this.AssertInvariant();
 
-			if ( this._dictionary == null )
+			if (this._dictionary == null)
 			{
-				int index = this._keys.FindIndex( item => item == key );
-				if ( index < 0 )
+				Debug.Assert(this._keys != null, "this._keys != null");
+				Debug.Assert(this._values != null, "this._values != null");
+
+				int index = this._keys.FindIndex(item => item == key);
+				if (index < 0)
 				{
 					value = MessagePackObject.Nil;
 					return false;
 				}
 				else
 				{
-					value = this._values[ index ];
+					value = this._values[index];
 					return true;
 				}
 			}
 			else
 			{
-				return this._dictionary.TryGetValue( key, out value );
+				return this._dictionary.TryGetValue(key, out value);
 			}
 		}
 
@@ -724,42 +642,43 @@ public bool TryGetValue( MessagePackObject key, out MessagePackObject value )
 		///		If the capacity must be increased to accommodate the new element, 
 		///		this method becomes an O(<em>N</em>) operation, where <em>N</em> is <see cref="Count"/>. 
 		/// </remarks>
-		public void Add( MessagePackObject key, MessagePackObject value )
+		public void Add(MessagePackObject key, MessagePackObject value)
 		{
-			if ( key.IsNil )
+			if (key.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
 			this.VerifyIsNotFrozen();
 
-			Contract.EndContractBlock();
-
-			this.AddCore( key, value, false );
+			this.AddCore(key, value, false);
 		}
 
-		private void AddCore( MessagePackObject key, MessagePackObject value, bool allowOverwrite )
+		private void AddCore(MessagePackObject key, MessagePackObject value, bool allowOverwrite)
 		{
-			Contract.Assert( !key.IsNil, "!key.IsNil" );
+			Debug.Assert(!key.IsNil, "!key.IsNil");
 
-			if ( this._dictionary == null )
+			if (this._dictionary == null)
 			{
-				if ( this._keys.Count < Threashold )
+				Debug.Assert(this._keys != null, "this._keys != null");
+				Debug.Assert(this._values != null, "this._values != null");
+
+				if (this._keys.Count < Threashold)
 				{
-					int index = this._keys.FindIndex( item => item == key );
-					if ( index < 0 )
+					int index = this._keys.FindIndex(item => item == key);
+					if (index < 0)
 					{
-						this._keys.Add( key );
-						this._values.Add( value );
+						this._keys.Add(key);
+						this._values.Add(value);
 					}
 					else
 					{
-						if ( !allowOverwrite )
+						if (!allowOverwrite)
 						{
-							ThrowDuplicatedKeyException( key, "key" );
+							ThrowDuplicatedKeyException(key, "key");
 						}
 
-						this._values[ index ] = value;
+						this._values[index] = value;
 					}
 
 					unchecked
@@ -769,12 +688,12 @@ private void AddCore( MessagePackObject key, MessagePackObject value, bool allow
 					return;
 				}
 
-				if ( this._keys.Count == Threashold && allowOverwrite )
+				if (this._keys.Count == Threashold && allowOverwrite)
 				{
-					int index = this._keys.FindIndex( item => item == key );
-					if ( 0 <= index )
+					int index = this._keys.FindIndex(item => item == key);
+					if (0 <= index)
 					{
-						this._values[ index ] = value;
+						this._values[index] = value;
 						unchecked
 						{
 							this._version++;
@@ -784,30 +703,30 @@ private void AddCore( MessagePackObject key, MessagePackObject value, bool allow
 				}
 
 				// Swith to hashtable base
-				this._dictionary = new Dictionary<MessagePackObject, MessagePackObject>( DictionaryInitialCapacity, MessagePackObjectEqualityComparer.Instance );
+				this._dictionary = new Dictionary<MessagePackObject, MessagePackObject>(DictionaryInitialCapacity, MessagePackObjectEqualityComparer.Instance);
 
-				for ( int i = 0; i < this._keys.Count; i++ )
+				for (int i = 0; i < this._keys.Count; i++)
 				{
-					this._dictionary.Add( this._keys[ i ], this._values[ i ] );
+					this._dictionary.Add(this._keys[i], this._values[i]);
 				}
 
 				this._keys = null;
 				this._values = null;
 			}
 
-			if ( allowOverwrite )
+			if (allowOverwrite)
 			{
-				this._dictionary[ key ] = value;
+				this._dictionary[key] = value;
 			}
 			else
 			{
 				try
 				{
-					this._dictionary.Add( key, value );
+					this._dictionary.Add(key, value);
 				}
-				catch ( ArgumentException )
+				catch (ArgumentException)
 				{
-					ThrowDuplicatedKeyException( key, "key" );
+					ThrowDuplicatedKeyException(key, "key");
 				}
 			}
 
@@ -817,38 +736,30 @@ private void AddCore( MessagePackObject key, MessagePackObject value, bool allow
 			}
 		}
 
-		void ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Add( KeyValuePair<MessagePackObject, MessagePackObject> item )
+		void ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Add(KeyValuePair<MessagePackObject, MessagePackObject> item)
 		{
-			if ( item.Key.IsNil )
+			if (item.Key.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
 			this.VerifyIsNotFrozen();
 
-			Contract.EndContractBlock();
-
-			this.AddCore( item.Key, item.Value, false );
+			this.AddCore(item.Key, item.Value, false);
 		}
 
-		void IDictionary.Add( object key, object value )
+		void IDictionary.Add(object key, object? value)
 		{
-			if ( key == null )
-			{
-				throw new ArgumentNullException( "key" );
-			}
-
+			Ensure.NotNull(key);
 			this.VerifyIsNotFrozen();
 
-			Contract.EndContractBlock();
-
-			var typedKey = ValidateObjectArgument( key, "key" );
-			if ( typedKey.IsNil )
+			var typedKey = ValidateObjectArgument(key);
+			if (typedKey.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
-			this.AddCore( typedKey, ValidateObjectArgument( value, "value" ), false );
+			this.AddCore(typedKey, ValidateObjectArgument(value), false);
 		}
 
 		/// <summary>
@@ -865,54 +776,55 @@ void IDictionary.Add( object key, object value )
 		/// <remarks>
 		///		This method approaches an O(1) operation.
 		/// </remarks>
-		public bool Remove( MessagePackObject key )
+		public bool Remove(MessagePackObject key)
 		{
-			if ( key.IsNil )
+			if (key.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
 			this.VerifyIsNotFrozen();
 
-			Contract.EndContractBlock();
-
-			return this.RemoveCore( key, default( MessagePackObject ), false );
+			return this.RemoveCore(key, default(MessagePackObject), false);
 		}
 
-		private bool RemoveCore( MessagePackObject key, MessagePackObject value, bool checkValue )
+		private bool RemoveCore(MessagePackObject key, MessagePackObject value, bool checkValue)
 		{
-			Contract.Assert( !key.IsNil, "!key.IsNil" );
+			Debug.Assert(!key.IsNil, "!key.IsNil");
 			this.AssertInvariant();
 
-			if ( this._dictionary == null )
+			if (this._dictionary == null)
 			{
-				int index = this._keys.FindIndex( item => item == key );
-				if ( index < 0 )
+				Debug.Assert(this._keys != null, "this._keys != null");
+				Debug.Assert(this._values != null, "this._values != null");
+
+				int index = this._keys.FindIndex(item => item == key);
+				if (index < 0)
 				{
 					return false;
 				}
 
-				if ( checkValue && this._values[ index ] != value )
+				if (checkValue && this._values[index] != value)
 				{
 					return false;
 				}
 
-				this._keys.RemoveAt( index );
-				this._values.RemoveAt( index );
+				this._keys.RemoveAt(index);
+				this._values.RemoveAt(index);
 			}
 			else
 			{
-				if ( checkValue )
+				if (checkValue)
 				{
-					if ( !( this._dictionary as ICollection<KeyValuePair<MessagePackObject, MessagePackObject>> ).Remove(
-						new KeyValuePair<MessagePackObject, MessagePackObject>( key, value ) ) )
+					if (!(this._dictionary as ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>).Remove(
+						new KeyValuePair<MessagePackObject, MessagePackObject>(key, value)))
 					{
 						return false;
 					}
 				}
 				else
 				{
-					if ( !this._dictionary.Remove( key ) )
+					if (!this._dictionary.Remove(key))
 					{
 						return false;
 					}
@@ -927,38 +839,31 @@ private bool RemoveCore( MessagePackObject key, MessagePackObject value, bool ch
 			return true;
 		}
 
-		bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Remove( KeyValuePair<MessagePackObject, MessagePackObject> item )
+		bool ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.Remove(KeyValuePair<MessagePackObject, MessagePackObject> item)
 		{
-			if ( item.Key.IsNil )
+			if (item.Key.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException("key");
 			}
 
 			this.VerifyIsNotFrozen();
 
-			Contract.EndContractBlock();
-
-			return this.RemoveCore( item.Key, item.Value, true );
+			return this.RemoveCore(item.Key, item.Value, true);
 		}
 
-		void IDictionary.Remove( object key )
+		void IDictionary.Remove(object key)
 		{
-			if ( key == null )
-			{
-				throw new ArgumentNullException( "key" );
-			}
+			Ensure.NotNull(key);
 
 			this.VerifyIsNotFrozen();
 
-			Contract.EndContractBlock();
-
-			var typedKey = ValidateObjectArgument( key, "key" );
-			if ( typedKey.IsNil )
+			var typedKey = ValidateObjectArgument(key);
+			if (typedKey.IsNil)
 			{
-				ThrowKeyNotNilException( "key" );
+				ThrowKeyNotNilException(nameof(key));
 			}
 
-			this.RemoveCore( typedKey, default( MessagePackObject ), false );
+			this.RemoveCore(typedKey, default(MessagePackObject), false);
 		}
 
 		/// <summary>
@@ -973,8 +878,11 @@ public void Clear()
 
 			this.AssertInvariant();
 
-			if ( this._dictionary == null )
+			if (this._dictionary == null)
 			{
+				Debug.Assert(this._keys != null, "this._keys != null");
+				Debug.Assert(this._values != null, "this._values != null");
+
 				this._keys.Clear();
 				this._values.Clear();
 			}
@@ -989,23 +897,22 @@ public void Clear()
 			}
 		}
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		void ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.CopyTo( KeyValuePair<MessagePackObject, MessagePackObject>[] array, int arrayIndex )
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		void ICollection<KeyValuePair<MessagePackObject, MessagePackObject>>.CopyTo(KeyValuePair<MessagePackObject, MessagePackObject>[] array, int arrayIndex)
 		{
-			CollectionOperation.CopyTo( this, this.Count, 0, array, arrayIndex, this.Count );
+			CollectionOperation.CopyTo(this, this.Count, 0, array, arrayIndex, this.Count);
 		}
 
-		[SuppressMessage( "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property." )]
-		void ICollection.CopyTo( Array array, int index )
+		[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "Child types should never call this property.")]
+		void ICollection.CopyTo(Array array, int index)
 		{
-			DictionaryEntry[] asDictionaryEntries;
-			if ( ( asDictionaryEntries = array as DictionaryEntry[] ) != null )
+			if (array is DictionaryEntry[] asDictionaryEntries)
 			{
-				CollectionOperation.CopyTo( this, this.Count, 0, asDictionaryEntries, index, array.Length, kv => new DictionaryEntry( kv.Key, kv.Value ) );
+				CollectionOperation.CopyTo(this, this.Count, 0, asDictionaryEntries, index, array.Length, kv => new DictionaryEntry(kv.Key, kv.Value));
 				return;
 			}
 
-			CollectionOperation.CopyTo( this, this.Count, array, index );
+			CollectionOperation.CopyTo(this, this.Count, array, index);
 		}
 
 		/// <summary>
@@ -1019,7 +926,7 @@ void ICollection.CopyTo( Array array, int index )
 		/// </remarks>
 		public Enumerator GetEnumerator()
 		{
-			return new Enumerator( this );
+			return new Enumerator(this);
 		}
 
 		IEnumerator<KeyValuePair<MessagePackObject, MessagePackObject>> IEnumerable<KeyValuePair<MessagePackObject, MessagePackObject>>.GetEnumerator()
@@ -1035,7 +942,7 @@ IEnumerator IEnumerable.GetEnumerator()
 		IDictionaryEnumerator IDictionary.GetEnumerator()
 		{
 			// Avoid tricky casting error.
-			return new DictionaryEnumerator( this );
+			return new DictionaryEnumerator(this);
 		}
 
 		/// <summary>
@@ -1068,7 +975,7 @@ public MessagePackObjectDictionary Freeze()
 		/// </remarks>
 		public MessagePackObjectDictionary AsFrozen()
 		{
-			return new MessagePackObjectDictionary( this ).Freeze();
+			return new MessagePackObjectDictionary(this).Freeze();
 		}
 	}
 }
diff --git a/src/MsgPack/MessagePackObjectEqualityComparer.cs b/src/MsgPack/MessagePackObjectEqualityComparer.cs
index 2f7551510..a66f8ad3d 100644
--- a/src/MsgPack/MessagePackObjectEqualityComparer.cs
+++ b/src/MsgPack/MessagePackObjectEqualityComparer.cs
@@ -1,26 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
@@ -28,29 +8,12 @@
 namespace MsgPack
 {
 	/// <summary>
-	///		Implements <see cref="EqualityComparer{T}"/> of <see cref="MessagePackObject"/>.
+	///		Implements <see cref="EqualityComparer{T}"/> for <see cref="MessagePackObject"/>.
 	/// </summary>
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 	[Serializable]
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	sealed class MessagePackObjectEqualityComparer : IEqualityComparer<MessagePackObject>
+	internal sealed class MessagePackObjectEqualityComparer : IEqualityComparer<MessagePackObject>
 	{
-		private static readonly MessagePackObjectEqualityComparer _instance = new MessagePackObjectEqualityComparer();
-
-#if UNITY && DEBUG
-		public
-#else
-		internal
-#endif
-		static MessagePackObjectEqualityComparer Instance
-		{
-			get { return _instance; }
-		}
+		internal static MessagePackObjectEqualityComparer Instance { get; } = new MessagePackObjectEqualityComparer();
 
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackObjectEqualityComparer"/> class.
@@ -65,10 +28,7 @@ public MessagePackObjectEqualityComparer() { }
 		/// <returns>
 		///		<c>true</c> if the specified objects are equal; otherwise, <c>false</c>.
 		/// </returns>
-		public bool Equals( MessagePackObject x, MessagePackObject y )
-		{
-			return x.Equals( y );
-		}
+		public bool Equals(MessagePackObject x, MessagePackObject y) => x.Equals(y);
 
 		/// <summary>
 		///		Returns a hash code for the specified <see cref="MessagePackObject"/>.
@@ -77,9 +37,6 @@ public bool Equals( MessagePackObject x, MessagePackObject y )
 		/// <returns>
 		///		A hash code for <paramref name="obj"/>, suitable for use in hashing algorithms and data structures like a hash table. 
 		/// </returns>
-		public int GetHashCode( MessagePackObject obj )
-		{
-			return obj.GetHashCode();
-		}
+		public int GetHashCode(MessagePackObject obj) => obj.GetHashCode();
 	}
 }
diff --git a/src/MsgPack/MessagePackString.cs b/src/MsgPack/MessagePackString.cs
index bad41a443..11699a1a9 100644
--- a/src/MsgPack/MessagePackString.cs
+++ b/src/MsgPack/MessagePackString.cs
@@ -1,41 +1,19 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Diagnostics;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 using System.Globalization;
 using System.Linq;
+#if FEATURE_CODE_ACCESS_SECURITY
 using System.Security;
+#endif // FEATURE_CODE_ACCESS_SECURITY
 using System.Text;
 using System.Threading;
+using MsgPack.Internal;
 
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations", Scope = "member", Target = "MsgPack.MessagePackString.#.cctor()", Justification = "Just create as marker" )]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations", Scope = "member", Target = "MsgPack.MessagePackString.#.cctor()", Justification = "Just create as marker")]
 
 namespace MsgPack
 {
@@ -47,54 +25,53 @@ namespace MsgPack
 #warning TODO: Enable in .NET Standard 2.0 in Changes.txt
 	[Serializable]
 #endif // FEATURE_BINARY_SERIALIZATION
+#if FEATURE_CODE_ACCESS_SECURITY
 	[SecuritySafeCritical]
-#endif // !NET35 && !UNITY
-	[DebuggerDisplay( "{DebuggerDisplayString}" )]
-	[DebuggerTypeProxy( typeof( MessagePackStringDebuggerProxy ) )]
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	sealed class MessagePackString
+#endif // FEATURE_CODE_ACCESS_SECURITY
+	[DebuggerDisplay("{DebuggerDisplayString}")]
+	[DebuggerTypeProxy(typeof(MessagePackStringDebuggerProxy))]
+	internal sealed class MessagePackString
 	{
-		// TODO: CLOB support?
 		// marker to indicate this is definitively binary.
-		private static readonly DecoderFallbackException IsBinary = new DecoderFallbackException( "This value is not string." );
-		private byte[] _encoded;
-		private string _decoded;
-		private DecoderFallbackException _decodingError;
+		private static readonly DecoderFallbackException IsBinary = new DecoderFallbackException("This value is not string.");
+		private ReadOnlyMemory<byte> _encoded;
+		private string? _decoded;
+		private DecoderFallbackException? _decodingError;
 		private BinaryType _type;
 
 		// ReSharper disable once UnusedMember.Local
-		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For debugger" )]
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "For debugger")]
 		private string DebuggerDisplayString
 		{
-			get { return new MessagePackStringDebuggerProxy( this ).Value; }
+			get { return new MessagePackStringDebuggerProxy(this).Value; }
 		}
 
-		public MessagePackString( string decoded )
+		public MessagePackString(string decoded)
 		{
-			Contract.Assert( decoded != null, "decoded != null" );
+			Debug.Assert(decoded != null, "decoded != null");
 
 			this._decoded = decoded;
 			this._type = BinaryType.String;
 		}
 
-		public MessagePackString( byte[] encoded, bool isBinary )
+		public MessagePackString(ReadOnlyMemory<char> decoded)
 		{
-			Contract.Assert( encoded != null, "encoded != null" );
+			this._decoded = decoded.ToString();
+			this._type = BinaryType.String;
+		}
 
+		public MessagePackString(ReadOnlyMemory<byte> encoded, bool isBinary)
+		{
 			this._encoded = encoded;
-			this._type = isBinary ? BinaryType.Blob : BinaryType.Unknwon;
-			if ( isBinary )
+			this._type = isBinary ? BinaryType.Blob : BinaryType.Unknown;
+			if (isBinary)
 			{
 				this._decodingError = IsBinary;
 			}
 		}
 
 		// Copy constructor for debugger proxy
-		private MessagePackString( MessagePackString other )
+		private MessagePackString(MessagePackString other)
 		{
 			this._encoded = other._encoded;
 			this._decoded = other._decoded;
@@ -104,76 +81,75 @@ private MessagePackString( MessagePackString other )
 
 		private void EncodeIfNeeded()
 		{
-			if ( this._encoded != null )
+			if (this._decoded == null)
 			{
 				return;
 			}
 
-			if ( this._decoded == null )
+			if (this._decoded.Length == 0)
 			{
 				return;
 			}
 
-			this._encoded = MessagePackConvert.Utf8NonBom.GetBytes( this._decoded );
-		}
-
-		private void DecodeIfNeeded()
-		{
-			if ( this._decoded != null )
+			if (this._encoded.Length > 0)
 			{
+				// Already encoded
 				return;
 			}
 
-			if ( this._encoded == null )
-			{
-				return;
-			}
+			this._encoded = Utf8EncodingNonBom.Instance.GetBytes(this._decoded);
+		}
 
-			if ( this._type != BinaryType.Unknwon )
+		private void DecodeIfNeeded()
+		{
+			if (this._type != BinaryType.Unknown)
 			{
 				return;
 			}
 
 			try
 			{
-				this._decoded = MessagePackConvert.DecodeStringStrict( this._encoded );
+				this._decoded = Utf8EncodingNonBomStrict.Instance.GetString(this._encoded.Span);
 				this._type = BinaryType.String;
 			}
-			catch ( DecoderFallbackException ex )
+			catch (DecoderFallbackException ex)
 			{
 				this._decodingError = ex;
 				this._type = BinaryType.Blob;
 			}
 		}
 
-		public string TryGetString()
+		public string? TryGetString()
 		{
 			this.DecodeIfNeeded();
 			return this._decoded;
 		}
 
-		public string GetString()
+		public string? GetString()
 		{
 			this.DecodeIfNeeded();
-			if ( this._decodingError != null )
+			if (this._decodingError != null)
 			{
-				throw new InvalidOperationException( "This bytes is not UTF-8 string.", this._decodingError == IsBinary ? default( Exception ) : this._decodingError );
+				throw new InvalidOperationException("This bytes is not UTF-8 string.", this._decodingError == IsBinary ? default(Exception) : this._decodingError);
 			}
 
 			return this._decoded;
 		}
 
-		public byte[] UnsafeGetBuffer()
-		{
-			return this._encoded;
-		}
+		public ReadOnlyMemory<char> GetCharMemory()
+			=> (this.GetString()?.AsMemory()).GetValueOrDefault();
 
-		public string UnsafeGetString()
+		public ReadOnlyMemory<byte> UnsafeGetMemory() => this._encoded;
+
+		public string? UnsafeGetString() => this._decoded;
+
+		public byte[] GetByteArray()
 		{
-			return this._decoded;
+			this.EncodeIfNeeded();
+			return this._encoded.ToArray();
 		}
 
-		public byte[] GetBytes()
+		public ReadOnlyMemory<byte> GetByteMemory()
 		{
 			this.EncodeIfNeeded();
 			return this._encoded;
@@ -182,173 +158,55 @@ public byte[] GetBytes()
 		public Type GetUnderlyingType()
 		{
 			this.DecodeIfNeeded();
-			return this._type == BinaryType.String ? typeof( string ) : typeof( byte[] );
+			return this._type == BinaryType.String ? typeof(string) : typeof(byte[]);
 		}
 
 		public override string ToString()
 		{
-			if ( this._decoded != null )
+			if (this._decoded != null)
 			{
 				return this._decoded;
 			}
 
-			if ( this._encoded != null )
-			{
-				return Binary.ToHexString( this._encoded );
-			}
-
-			return String.Empty;
+			return Binary.ToHexString(this._encoded.Span);
 		}
 
 		public override int GetHashCode()
 		{
-			// ReSharper disable NonReadonlyFieldInGetHashCode
-			if ( this._decoded != null )
-			{
-				return this._decoded.GetHashCode();
-			}
-
-			this.DecodeIfNeeded();
-			if ( this._decoded != null )
-			{
-				return this._decoded.GetHashCode();
-			}
-
-			if ( this._encoded != null )
-			{
-				int hashCode = 0;
-				for ( int i = 0; i < this._encoded.Length; i++ )
-				{
-					int value = this._encoded[ i ] << ( i % 4 ) * 8;
-					hashCode ^= value;
-				}
-
-				return hashCode;
-			}
-
-			return 0;
-			// ReSharper restore NonReadonlyFieldInGetHashCode
-		}
-
-		public override bool Equals( object obj )
-		{
-			var other = obj as MessagePackString;
-			if ( ReferenceEquals( other, null ) )
-			{
-				return false;
-			}
-
-			if ( this._decoded != null && other._decoded != null )
-			{
-				return this._decoded == other._decoded;
-			}
-
-			if ( this._decoded == null && other._decoded == null )
-			{
-				return EqualsEncoded( this, other );
-			}
-
-			this.DecodeIfNeeded();
-			other.DecodeIfNeeded();
-
-			return this._decoded == other._decoded;
+			this.EncodeIfNeeded();
+			return FarmHash.Hash32WithSeed(this._encoded.Span, FarmHash.DefaultSeed);
 		}
 
-		private static bool EqualsEncoded( MessagePackString left, MessagePackString right )
+		public override bool Equals(object? obj)
 		{
-			if ( left._encoded == null )
-			{
-				return right._encoded == null;
-			}
-
-			if ( left._encoded.Length == 0 )
-			{
-				return right._encoded.Length == 0;
-			}
-
-			if ( left._encoded.Length != right._encoded.Length )
+			if (!(obj is MessagePackString other))
 			{
 				return false;
 			}
 
-#if !UNITY && !WINDOWS_PHONE && !NETFX_CORE && !UNITY
-			if ( _isFastEqualsDisabled == 0 )
+			if (ReferenceEquals(this, other))
 			{
-				try
-				{
-					return UnsafeFastEquals( left._encoded, right._encoded );
-				}
-				catch ( SecurityException )
-				{
-					Interlocked.Exchange( ref _isFastEqualsDisabled, 1 );
-				}
-				catch ( MemberAccessException )
-				{
-					Interlocked.Exchange( ref _isFastEqualsDisabled, 1 );
-				}
+				return true;
 			}
-#endif // if !UNITY && !WINDOWS_PHONE && !NETFX_CORE && !UNITY;
 
-			return SlowEquals( left._encoded, right._encoded );
-		}
-
-		private static bool SlowEquals( byte[] x, byte[] y )
-		{
-			for ( int i = 0; i < x.Length; i++ )
+			if (this._type == other._type && this._type == BinaryType.String)
 			{
-				if ( x[ i ] != y[ i ] )
-				{
-					return false;
-				}
+				// Compare between string and string.
+				return this._decoded == other._decoded;
 			}
 
-			return true;
-		}
-
-#if !UNITY && !WINDOWS_PHONE && !NETFX_CORE && !UNITY
-#if SILVERLIGHT
-		private static int _isFastEqualsDisabled =
-			System.Windows.Application.Current.HasElevatedPermissions ? 0 : 1;
-#else
-		private static int _isFastEqualsDisabled;
-#endif // if SILVERLIGHT
-
-#if DEBUG
-		// for testing
-		internal static bool IsFastEqualsDisabled
-		{
-			get { return _isFastEqualsDisabled != 0; }
-		}
-#endif
-
-#if !NET35 && !UNITY
-		[SecuritySafeCritical]
-#endif // !NET35 && !UNITY
-		private static bool UnsafeFastEquals( byte[] x, byte[] y )
-		{
-#if DEBUG
-			Contract.Assert( x != null, "x != null" );
-			Contract.Assert( y != null, "y != null" );
-			Contract.Assert( 0 < x.Length, "0 < x.Length" );
-			Contract.Assert( x.Length == y.Length, "x.Length == y.Length" );
-#endif // if DEBUG
-			int result;
-			if ( !UnsafeNativeMethods.TryMemCmp( x, y, new UIntPtr( unchecked( ( uint )x.Length ) ), out result ) )
-			{
-				Interlocked.Exchange( ref _isFastEqualsDisabled, 1 );
-				return SlowEquals( x, y );
-			}
+			this.EncodeIfNeeded();
+			other.EncodeIfNeeded();
 
-			return result == 0;
+			return this._encoded.Span.SequenceEqual(other._encoded.Span);
 		}
-#endif // if !UNITY && !WINDOWS_PHONE && !NETFX_CORE && !UNITY;
 
 #if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		[Serializable]
 #endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 		private enum BinaryType
 		{
-			Unknwon = 0,
+			Unknown = 0,
 			String,
 			Blob
 		}
@@ -356,24 +214,24 @@ private enum BinaryType
 		internal sealed class MessagePackStringDebuggerProxy
 		{
 			private readonly MessagePackString _target;
-			private string _asByteArray;
+			private string? _asByteArray;
 
-			public MessagePackStringDebuggerProxy( MessagePackString target )
+			public MessagePackStringDebuggerProxy(MessagePackString target)
 			{
-				this._target = new MessagePackString( target );
+				this._target = new MessagePackString(target);
 			}
 
 			public string Value
 			{
 				get
 				{
-					var asByteArray = Interlocked.CompareExchange( ref this._asByteArray, null, null );
-					if ( asByteArray != null )
+					var asByteArray = Interlocked.CompareExchange(ref this._asByteArray, null, null);
+					if (asByteArray != null)
 					{
 						return asByteArray;
 					}
 
-					switch ( this._target._type )
+					switch (this._target._type)
 					{
 						case BinaryType.Blob:
 						{
@@ -392,17 +250,17 @@ public string Value
 				}
 			}
 
-			public string AsString
+			public string? AsString
 			{
 				get
 				{
 					var value = this._target.TryGetString();
-					if ( value == null )
+					if (value == null)
 					{
 						return null;
 					}
 
-					if ( !MustBeString( value ) )
+					if (!MustBeString(value))
 					{
 						this.CreateByteArrayString();
 						return null;
@@ -412,16 +270,16 @@ public string AsString
 				}
 			}
 
-			private static bool MustBeString( string value )
+			private static bool MustBeString(string value)
 			{
-				for ( int i = 0; i < 128 && i < value.Length; i++ )
+				for (int i = 0; i < 128 && i < value.Length; i++)
 				{
-					var c = value[ i ];
-					if ( c < 0x20 && ( c != 0x9 && c != 0xA && c != 0xD ) )
+					var c = value[i];
+					if (c < 0x20 && (c != 0x9 && c != 0xA && c != 0xD))
 					{
 						return false;
 					}
-					else if ( 0x7E < c && c < 0xA0 )
+					else if (0x7E < c && c < 0xA0)
 					{
 						return false;
 					}
@@ -434,8 +292,8 @@ public string AsByteArray
 			{
 				get
 				{
-					var value = Interlocked.CompareExchange( ref this._asByteArray, null, null );
-					if ( value == null )
+					var value = Interlocked.CompareExchange(ref this._asByteArray, null, null);
+					if (value == null)
 					{
 						value = this.CreateByteArrayString();
 					}
@@ -446,19 +304,19 @@ public string AsByteArray
 
 			private string CreateByteArrayString()
 			{
-				var bytes = this._target.GetBytes();
-				var buffer = new StringBuilder( ( bytes.Length <= 128 ? bytes.Length * 3 : 128 * 3 + 3 ) + 4 );
-				buffer.Append( '[' );
+				var bytes = this._target.GetByteMemory();
+				var buffer = new StringBuilder((bytes.Length <= 128 ? bytes.Length * 3 : 128 * 3 + 3) + 4);
+				buffer.Append('[');
 
-				foreach ( var b in bytes.Take( 128 ) )
+				foreach (var b in bytes.Slice(0, 128).Span)
 				{
-					buffer.Append( ' ' );
-					buffer.Append( b.ToString( "X2", CultureInfo.InvariantCulture ) );
+					buffer.Append(' ');
+					buffer.Append(b.ToString("X2", CultureInfo.InvariantCulture));
 				}
-				buffer.Append( " ]" );
+				buffer.Append(" ]");
 
 				var value = buffer.ToString();
-				Interlocked.Exchange( ref this._asByteArray, value );
+				Interlocked.Exchange(ref this._asByteArray, value);
 				return value;
 			}
 		}
diff --git a/src/MsgPack/MessageTypeException.cs b/src/MsgPack/MessageTypeException.cs
index 6ce2e5c39..7707b26f7 100644
--- a/src/MsgPack/MessageTypeException.cs
+++ b/src/MsgPack/MessageTypeException.cs
@@ -1,24 +1,9 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
+using System.ComponentModel;
 #if FEATURE_BINARY_SERIALIZATION
 using System.Runtime.Serialization;
 #endif // FEATURE_BINARY_SERIALIZATION
@@ -31,18 +16,27 @@ namespace MsgPack
 #if FEATURE_BINARY_SERIALIZATION
 	[Serializable]
 #endif // FEATURE_BINARY_SERIALIZATION
+	public class MessageTypeException : DecodeException
 	{
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with the default error message.
 		/// </summary>
+		[Obsolete("Use .ctor(long) instead.")]
+		[EditorBrowsable(EditorBrowsableState.Never)]
 		public MessageTypeException() : this(null) { }
 
+		public MessageTypeException(long position) : this(position, null) { }
+
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with a specified error message.
 		/// </summary>
 		/// <param name="message">The message that describes the error. </param>
+		[Obsolete("Use .ctor(long, string?) instead.")]
+		[EditorBrowsable(EditorBrowsableState.Never)]
 		public MessageTypeException(string? message) : this(message, null) { }
 
+		public MessageTypeException(long position, string? message) : this(position, message, null) { }
+
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception. 
 		/// </summary>
@@ -50,7 +44,13 @@ public MessageTypeException(string? message) : this(message, null) { }
 		/// <param name="inner">
 		///		The exception that is the cause of the current exception, or a <c>null</c> if no inner exception is specified.
 		/// </param>
-		public MessageTypeException(string? message, Exception? inner) : base(message ?? "Invalid message type.", inner) { }
+		[Obsolete("Use .ctor(long, string?, Exception?) instead.")]
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public MessageTypeException(string? message, Exception? inner) : this(0, message ?? "Invalid message type.", inner) { }
+
+		public MessageTypeException(long position, string? message, Exception? innerException)
+			:base(position, message, innerException) { }
+
 #if FEATURE_BINARY_SERIALIZATION
 
 		/// <summary>

From eddf64e9308f47f6a9fc1b9bc7930d2adb3fdecb Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:14:46 +0900
Subject: [PATCH 59/82] WIP: Rever BindingOptions

This option should be revised for 2.0 and has not been released yet,
so this definition should be removed.
---
 src/MsgPack/Serialization/BindingOptions.cs | 73 ---------------------
 1 file changed, 73 deletions(-)
 delete mode 100644 src/MsgPack/Serialization/BindingOptions.cs

diff --git a/src/MsgPack/Serialization/BindingOptions.cs b/src/MsgPack/Serialization/BindingOptions.cs
deleted file mode 100644
index f0b2fd696..000000000
--- a/src/MsgPack/Serialization/BindingOptions.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace MsgPack.Serialization
-{
-	/// <summary>
-	/// The Binding Options provide serializer clue on including property/field as part of packing.
-	/// </summary>
-	public class BindingOptions
-	{
-		/// <summary>
-		/// Private mapping of types &amp; their member skip list, which needs to ignore as part of serialization.
-		/// </summary>
-		private readonly IDictionary<Type, IEnumerable<string>> _typeIgnoringMembersMap = new Dictionary<Type, IEnumerable<string>>();
-
-		/// <summary>
-		/// Sets the member skip list for a specific target type.
-		/// </summary>
-		/// <param name="targetType">Type of the target.</param>
-		/// <param name="memberSkipList">The member skip list.</param>
-		public void SetIgnoringMembers(Type targetType, IEnumerable<string> memberSkipList)
-		{
-			lock (this._typeIgnoringMembersMap)
-			{
-				if (this._typeIgnoringMembersMap.ContainsKey(targetType))
-				{
-					this._typeIgnoringMembersMap[targetType] = memberSkipList;
-				}
-				else
-				{
-					this._typeIgnoringMembersMap.Add(targetType, memberSkipList);
-				}
-			}
-		}
-
-		/// <summary>
-		/// Gets the member skip list for a specific target type.
-		/// </summary>
-		/// <param name="targetType">Type of the target.</param>
-		/// <returns>Returns member skip list for a specific target type.</returns>
-		public IEnumerable<string> GetIgnoringMembers(Type targetType)
-		{
-			lock (this._typeIgnoringMembersMap)
-			{
-				if (this._typeIgnoringMembersMap.ContainsKey(targetType))
-				{
-					return this._typeIgnoringMembersMap[targetType];
-				}
-				else
-				{
-					return Enumerable.Empty<string>();
-				}
-			}
-		}
-
-		/// <summary>
-		/// Gets all registered types specific ignoring members.
-		/// </summary>
-		/// <returns>Returns all registered types specific ignoring members.</returns>
-		public IDictionary<Type, IEnumerable<string>> GetAllIgnoringMembers()
-		{
-			lock (this._typeIgnoringMembersMap)
-			{
-				return this._typeIgnoringMembersMap.ToDictionary(item => item.Key, item => (IEnumerable<string>)item.Value.ToArray());
-			}
-		}
-	}
-}

From ccff3fe0c3c83bd9fa649a00a6f43de328dc5efe Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:15:37 +0900
Subject: [PATCH 60/82] Fix CollectionContext exception bug

---
 src/MsgPack.Abstraction/Internal/CollectionContext.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/CollectionContext.cs b/src/MsgPack.Abstraction/Internal/CollectionContext.cs
index 75b82355e..48947396e 100644
--- a/src/MsgPack.Abstraction/Internal/CollectionContext.cs
+++ b/src/MsgPack.Abstraction/Internal/CollectionContext.cs
@@ -27,11 +27,11 @@ internal CollectionContext(int maxArrayLength, int maxMapCount, int maxDepth, in
 			this.CurrentDepth = currentDepth;
 		}
 
-		public int IncrementDepth()
+		public int IncrementDepth(long position)
 		{
 			if (this.CurrentDepth == this.MaxDepth)
 			{
-				Throw.DepthExeeded(this.CurrentDepth, this.MaxDepth);
+				Throw.DepthExeeded(position, this.MaxDepth);
 			}
 
 			return this.CurrentDepth++;

From 9a04b9c6ff873eff6f59a4758d0bdde68e8aeab8 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:16:10 +0900
Subject: [PATCH 61/82] Add blank validation with trimming

---
 src/MsgPack.Abstraction/Ensure.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/MsgPack.Abstraction/Ensure.cs b/src/MsgPack.Abstraction/Ensure.cs
index 18517a85d..96b7fc4ca 100644
--- a/src/MsgPack.Abstraction/Ensure.cs
+++ b/src/MsgPack.Abstraction/Ensure.cs
@@ -45,6 +45,18 @@ public static string NotBlank([NotNull] string? value, [CallerArgumentExpression
 			return value;
 		}
 
+		public static string NotBlankAndTrimmed([NotNull] string? value, [CallerArgumentExpression("value")] string paramName = null!)
+		{
+			NotNull(value);
+
+			if (String.IsNullOrWhiteSpace(value))
+			{
+				ThrowArgumentBlankString(paramName);
+			}
+
+			return value.Trim();
+		}
+
 		public static int IsNotNegative(int value, [CallerArgumentExpression("value")]string paramName = null!)
 		{
 			if (value < 0)

From 954d24120b3d238fe34cc9bf1d17069906177fa5 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:16:26 +0900
Subject: [PATCH 62/82] Add enum validation

---
 src/MsgPack.Abstraction/Ensure.Enum.cs | 77 ++++++++++++++++++++++++++
 src/MsgPack.Abstraction/Ensure.cs      |  2 +-
 2 files changed, 78 insertions(+), 1 deletion(-)
 create mode 100644 src/MsgPack.Abstraction/Ensure.Enum.cs

diff --git a/src/MsgPack.Abstraction/Ensure.Enum.cs b/src/MsgPack.Abstraction/Ensure.Enum.cs
new file mode 100644
index 000000000..a25224163
--- /dev/null
+++ b/src/MsgPack.Abstraction/Ensure.Enum.cs
@@ -0,0 +1,77 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace MsgPack
+{
+	internal partial class Ensure
+	{
+		public static T Defined<T>(T value, [CallerArgumentExpression("value")] string? paramName = null)
+			where T : Enum
+		{
+			if (EnumValidationHelper<T>.Instance.IsDefined(value))
+			{
+				throw new ArgumentOutOfRangeException(paramName);
+			}
+
+			return value;
+		}
+
+		private sealed class EnumValidationHelper<T>
+			where T : Enum
+		{
+			public static readonly EnumValidationHelper<T> Instance = new EnumValidationHelper<T>();
+
+			private readonly ulong _undefinedFlags;
+			private readonly ulong[] _constants;
+			private readonly bool _isFlags;
+
+			private EnumValidationHelper()
+			{
+				this._isFlags = typeof(T).IsDefined(typeof(FlagsAttribute));
+				var underlyingType = Enum.GetUnderlyingType(typeof(T));
+				var values =
+					(Enum.GetValues(typeof(T)) as object[])
+					.Select(v => Convert.ToUInt64(v))
+					.ToArray();
+
+				if (!this._isFlags)
+				{
+					Array.Sort(values);
+					this._constants = values;
+					this._undefinedFlags = default!;
+				}
+				else
+				{
+					this._constants = Array.Empty<ulong>();
+					var flags = default(ulong);
+					foreach(var flag in values)
+					{
+						flags |= flag;
+					}
+
+					this._undefinedFlags = ~flags;
+				}
+			}
+
+			public bool IsDefined(T value)
+			{
+				var bits = Unsafe.As<T, ulong>(ref value);
+
+				if (this._isFlags)
+				{
+					return (bits & this._undefinedFlags) == 0;
+				}
+				else
+				{
+					return Array.BinarySearch(this._constants, bits) >= 0;
+				}
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Ensure.cs b/src/MsgPack.Abstraction/Ensure.cs
index 96b7fc4ca..4a9492987 100644
--- a/src/MsgPack.Abstraction/Ensure.cs
+++ b/src/MsgPack.Abstraction/Ensure.cs
@@ -8,7 +8,7 @@
 
 namespace MsgPack
 {
-	internal static class Ensure
+	internal static partial class Ensure
 	{
 		[return: NotNull]
 		public static T NotNull<T>([NotNull]T value, [CallerArgumentExpression("value")]string paramName = null!)

From 51e7a81f9a10229a1188e716a7ec3397396cc4ba Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:17:23 +0900
Subject: [PATCH 63/82] Implement common methods of ExtensionTypeObject

---
 .../ExtensionTypeObject.cs                    | 136 +++++++++++++++++-
 1 file changed, 135 insertions(+), 1 deletion(-)

diff --git a/src/MsgPack.Abstraction/ExtensionTypeObject.cs b/src/MsgPack.Abstraction/ExtensionTypeObject.cs
index 3296250a4..fc2b60731 100644
--- a/src/MsgPack.Abstraction/ExtensionTypeObject.cs
+++ b/src/MsgPack.Abstraction/ExtensionTypeObject.cs
@@ -2,7 +2,11 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
+using System;
 using System.Buffers;
+using System.Diagnostics;
+using System.Text;
+using MsgPack.Internal;
 
 namespace MsgPack
 {
@@ -13,7 +17,7 @@ namespace MsgPack
 	///		Valid range and sementics of <see cref="Type"/> depend on serialization codec.
 	///		In addition, some codec does not support extension type at all.
 	/// </remarks>
-	public readonly struct ExtensionTypeObject
+	public readonly struct ExtensionTypeObject : IEquatable<ExtensionTypeObject>
 	{
 		/// <summary>
 		///		Gets a type of this extension type data.
@@ -37,5 +41,135 @@ public ExtensionTypeObject(ExtensionType type, ReadOnlySequence<byte> body)
 			this.Type = type;
 			this.Body = body;
 		}
+
+		public override string ToString()
+		{
+			const int tokensLength = 3 + 8 + 3 + 20 + 3 + 4 + 4 + 3;
+			var buffer = StringBuilderCache.Acquire((int)Math.Min(0x2000 + tokensLength, tokensLength + this.Body.Length * 2));
+			try
+			{
+				this.ToString(buffer, false);
+				return buffer.ToString();
+			}
+			finally
+			{
+				StringBuilderCache.Release(buffer);
+			}
+		}
+
+		internal void ToString(StringBuilder buffer, bool isJson)
+		{
+			if (isJson)
+			{
+				buffer.Append("{ \"TypeCode\": ").Append(this.Type.Tag).Append(", \"Body\": \"");
+				
+				var body = this.Body.Slice(0, 0x2000);
+	
+				const int byteSpanLength = 96;
+				const int charSpanLength = byteSpanLength / 3 * 4;
+				Span<char> charSpan = stackalloc char[charSpanLength];
+				Span<byte> byteSpan = stackalloc byte[byteSpanLength];
+				while (!body.IsEmpty)
+				{
+					body.CopyTo(byteSpan);
+					var byteLength = (int)Math.Min(body.Length, byteSpanLength);
+					Convert.TryToBase64Chars(byteSpan.Slice(0, byteLength), charSpan, out var charsWritten, Base64FormattingOptions.None);
+					buffer.Append(charSpan.Slice(0, charsWritten));
+					body = body.Slice(byteLength);
+				}
+
+				buffer.Append("\" }");
+			}
+			else
+			{
+				buffer.Append("[").Append(this.Type.Tag).Append("]0x");
+				var body = this.Body.Slice(0, 0x5000000);
+				while (!body.IsEmpty)
+				{
+					Binary.ToHexString(body.FirstSpan, buffer);
+					body = body.Slice(body.First.Length);
+				}
+			}
+		}
+
+
+		/// <inheritdoc />
+		public override bool Equals(object? obj)
+			=> obj is ExtensionTypeObject other ? this.Equals(other) : false;
+
+		/// <inheritdoc />
+		public bool Equals(ExtensionTypeObject other)
+		{
+			if (this.Type != other.Type)
+			{
+				return false;
+			}
+
+			if (this.Body.Length != other.Body.Length)
+			{
+				return false;
+			}
+
+			if (this.Body.IsSingleSegment && other.Body.IsSingleSegment)
+			{
+				return this.Body.FirstSpan.SequenceEqual(other.Body.FirstSpan);
+			}
+
+			var thisBody = this.Body;
+			var otherBody = other.Body;
+			do
+			{
+				var length = Math.Min(thisBody.FirstSpan.Length, otherBody.FirstSpan.Length);
+				var left = thisBody.FirstSpan.Slice(0, length);
+				var right = otherBody.FirstSpan.Slice(0, length);
+				if (!left.SequenceEqual(right))
+				{
+					return false;
+				}
+
+				thisBody = thisBody.Slice(length);
+				otherBody = otherBody.Slice(length);			
+			} while (!thisBody.IsEmpty);
+
+			Debug.Assert(otherBody.IsEmpty);
+
+			return true;
+		}
+
+		/// <inheritdoc />
+		public override int GetHashCode()
+		{
+			var hashCode = this.Type.GetHashCode();
+			var body = this.Body;
+			while(!body.IsEmpty)
+			{
+				hashCode ^= FarmHash.Hash32WithSeed(body.FirstSpan, FarmHash.DefaultSeed);
+				body = body.Slice(body.FirstSpan.Length);
+			}
+
+			return hashCode;
+		}
+
+		/// <summary>
+		///		Determines whether two specified instances of <see cref="ExtensionTypeObject"/> are equal.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> and <paramref name="right"/> represent the same type; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator ==(ExtensionTypeObject left, ExtensionTypeObject right)
+			=> left.Equals(right);
+
+		/// <summary>
+		///		Determines whether two specified instances of <see cref="ExtensionTypeObject"/> are not equal.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="left"/> and <paramref name="right"/> represent the different type; otherwise, <c>false</c>.
+		///	</returns>
+		public static bool operator !=(ExtensionTypeObject left, ExtensionTypeObject right)
+			=> !left.Equals(right);
 	}
 }

From e3928906edca16025504f88ea05feda9a1c035a6 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:18:41 +0900
Subject: [PATCH 64/82] Implement position reporting basics

---
 src/MsgPack.Abstraction/DecodeException.cs    | 69 +++++++++++++++++++
 .../InsufficientInputException.cs             | 15 ++--
 .../Internal/ReadOnlyStreamSequence.cs        |  9 +++
 .../LimitExceededException.cs                 | 15 ++--
 .../MessageFormatException.cs                 | 33 +++++++++
 5 files changed, 127 insertions(+), 14 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/DecodeException.cs
 create mode 100644 src/MsgPack.Abstraction/MessageFormatException.cs

diff --git a/src/MsgPack.Abstraction/DecodeException.cs b/src/MsgPack.Abstraction/DecodeException.cs
new file mode 100644
index 000000000..87fc53411
--- /dev/null
+++ b/src/MsgPack.Abstraction/DecodeException.cs
@@ -0,0 +1,69 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+#if FEATURE_BINARY_SERIALIZATION
+using System.Runtime.Serialization;
+#endif // FEATURE_BINARY_SERIALIZATION
+
+namespace MsgPack
+{
+#warning TODO: -> ParseException
+	/// <summary>
+	///		Defines common exception for decoding error which is caused by invalid input byte sequence.
+	/// </summary>
+#if FEATURE_BINARY_SERIALIZATION
+	[Serializable]
+#endif // FEATURE_BINARY_SERIALIZATION
+	public abstract class DecodeException : Exception
+	{
+		/// <summary>
+		///		Gets the position of the input sequence.
+		/// </summary>
+		/// <value>
+		///		The position of the input sequence.
+		/// </value>
+		/// <remarks>
+		///		This value MAY NOT represents actual position of source byte sequence espetially in asynchronous deserialization 
+		///		because the position stored in this property may reflect the offset in the buffer which is gotten from underlying byte stream rather than the stream position.
+		///		So, the serializer, which is consumer of the decoder,  must provide appropriate exception message with calculated position information with this property.
+		///		
+		///		<note>Because of above limitation, this property's value will not included in <see cref="P:Message"/> property nand <see cref="M:ToString()"/> result.</note>
+		/// </remarks>
+		public long Position { get; }
+
+		protected DecodeException(long position)
+			: base()
+		{
+			this.Position = position;
+		}
+
+		protected DecodeException(long position, string? message)
+			: base(message)
+		{
+			this.Position = position;
+		}
+
+		protected DecodeException(long position, string? message, Exception? innerException)
+			: base(message, innerException)
+		{
+			this.Position = position;
+		}
+
+#if FEATURE_BINARY_SERIALIZATION
+		protected DecodeException(SerializationInfo info, StreamingContext context)
+			: base(info, context)
+		{
+			this.Position = info.GetInt64("Position");
+		}
+
+		public override void GetObjectData(SerializationInfo info, StreamingContext context)
+		{
+			base.GetObjectData(info, context);
+			info.AddValue("Position", this.Position);
+		}
+
+#endif // FEATURE_BINARY_SERIALIZATION
+	}
+}
diff --git a/src/MsgPack.Abstraction/InsufficientInputException.cs b/src/MsgPack.Abstraction/InsufficientInputException.cs
index 857b66460..5850afb43 100644
--- a/src/MsgPack.Abstraction/InsufficientInputException.cs
+++ b/src/MsgPack.Abstraction/InsufficientInputException.cs
@@ -15,16 +15,17 @@ namespace MsgPack
 #if FEATURE_BINARY_SERIALIZATION
 	[Serializable]
 #endif // FEATURE_BINARY_SERIALIZATION
-	public sealed class InsufficientInputException : Exception
+	public sealed class InsufficientInputException : DecodeException
 	{
-		public InsufficientInputException()
-			: this("There are no more inputs.") { }
+		public InsufficientInputException(long position)
+			: this(position, "There are no more inputs.") { }
 
-		public InsufficientInputException(string? message)
-			: base(message) { }
+		public InsufficientInputException(long position, string? message)
+			: base(position, message) { }
+
+		public InsufficientInputException(long position, string? message, Exception? innerException)
+			: base(position, message, innerException) { }
 
-		public InsufficientInputException(string? message, Exception? innerException)
-			: base(message, innerException) { }
 #if FEATURE_BINARY_SERIALIZATION
 
 		private InsufficientInputException(SerializationInfo info, StreamingContext context)
diff --git a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
index e5e9acaa7..d6a76399f 100644
--- a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
+++ b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
@@ -24,6 +24,14 @@ public sealed class ReadOnlyStreamSequence : IDisposable
 		private readonly Stream _stream; // DO NOT Dispose this in this class.
 		private byte[] _array;
 
+		/// <summary>
+		///		Gets the position of the head of the <see cref="Memory"/> on underlying <see cref="Stream"/>.
+		/// </summary>
+		/// <value>
+		///		The position of the head of the <see cref="Memory"/> on underlying <see cref="Stream"/>.
+		/// </value>
+		public long Position { get; private set; }
+
 		/// <summary>
 		///		Gets internal buffer as <see cref="ReadOnlyMemory{Byte}"/> which holds last fetched data.
 		/// </summary>
@@ -117,6 +125,7 @@ public void Advance(long length)
 			}
 
 			this.Memory = this.Memory.Slice((int)Ensure.IsNotGreaterThan(length, (long)this.Memory.Length));
+			this.Position += length;
 		}
 	}
 }
diff --git a/src/MsgPack.Abstraction/LimitExceededException.cs b/src/MsgPack.Abstraction/LimitExceededException.cs
index 1fb5841be..cf2ff5a03 100644
--- a/src/MsgPack.Abstraction/LimitExceededException.cs
+++ b/src/MsgPack.Abstraction/LimitExceededException.cs
@@ -12,16 +12,17 @@ namespace MsgPack
 #if FEATURE_BINARY_SERIALIZATION
 	[Serializable]
 #endif // FEATURE_BINARY_SERIALIZATION
-	public sealed class LimitExceededException : Exception
+	public sealed class LimitExceededException : DecodeException
 	{
-		public LimitExceededException()
-			: this("Some limit is exeeded.") { }
+		public LimitExceededException(long potision)
+			: this(potision, "Some limit is exeeded.") { }
 
-		public LimitExceededException(string? message)
-			: base(message) { }
+		public LimitExceededException(long potision, string? message)
+			: base(potision, message) { }
+
+		public LimitExceededException(long potision, string? message, Exception? innerException)
+			: base(potision, message, innerException) { }
 
-		public LimitExceededException(string? message, Exception? innerException)
-			: base(message, innerException) { }
 #if FEATURE_BINARY_SERIALIZATION
 
 		private LimitExceededException(SerializationInfo info, StreamingContext context)
diff --git a/src/MsgPack.Abstraction/MessageFormatException.cs b/src/MsgPack.Abstraction/MessageFormatException.cs
new file mode 100644
index 000000000..722616721
--- /dev/null
+++ b/src/MsgPack.Abstraction/MessageFormatException.cs
@@ -0,0 +1,33 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+#if FEATURE_BINARY_SERIALIZATION
+using System.Runtime.Serialization;
+#endif // FEATURE_BINARY_SERIALIZATION
+
+namespace MsgPack
+{
+#if FEATURE_BINARY_SERIALIZATION
+	[Serializable]
+#endif // FEATURE_BINARY_SERIALIZATION
+	public sealed class MessageFormatException : DecodeException
+	{
+		public MessageFormatException(long position)
+			: this(position, "Input has invalid byte sequence.") { }
+
+		public MessageFormatException(long position, string? message)
+			: base(position, message) { }
+
+		public MessageFormatException(long position, string? message, Exception? innerException)
+			: base(position, message, innerException) { }
+
+#if FEATURE_BINARY_SERIALIZATION
+
+		private MessageFormatException(SerializationInfo info, StreamingContext context)
+			: base(info, context) { }
+
+#endif // FEATURE_BINARY_SERIALIZATION
+	}
+}

From 821e1bdaac96af8428d613bee154e6685ec1c123 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:18:47 +0900
Subject: [PATCH 65/82] Fix typo

---
 src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
index d6a76399f..58334cd6a 100644
--- a/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
+++ b/src/MsgPack.Abstraction/Internal/ReadOnlyStreamSequence.cs
@@ -103,7 +103,7 @@ public async ValueTask FetchAsync(int requestHint, CancellationToken cancellatio
 			}
 			else
 			{
-				// comact
+				// compact
 				this.Memory.CopyTo(this._array);
 			}
 

From 7f64323f15fdab0273047ce1ceb4741b697c6e89 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:19:42 +0900
Subject: [PATCH 66/82] Add default encoding

---
 .../Internal/Utf8EncodingNonBomStrict.cs      | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 src/MsgPack.Abstraction/Internal/Utf8EncodingNonBomStrict.cs

diff --git a/src/MsgPack.Abstraction/Internal/Utf8EncodingNonBomStrict.cs b/src/MsgPack.Abstraction/Internal/Utf8EncodingNonBomStrict.cs
new file mode 100644
index 000000000..b30665ab6
--- /dev/null
+++ b/src/MsgPack.Abstraction/Internal/Utf8EncodingNonBomStrict.cs
@@ -0,0 +1,24 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Text;
+
+namespace MsgPack.Internal
+{
+	/// <summary>
+	///		Defines sealed UTF-8 class which cannot emit BOM and throws Exception.
+	/// </summary>
+	/// <remarks>
+	///		Sealed class typed static constant is important for JIT devirtualization optimization.
+	/// </remarks>
+	internal sealed class Utf8EncodingNonBomStrict : UTF8Encoding
+	{
+		public static Utf8EncodingNonBomStrict Instance { get; } = new Utf8EncodingNonBomStrict();
+
+		private Utf8EncodingNonBomStrict() : base(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true)
+		{
+			this.DecoderFallback = DecoderFallback.ExceptionFallback;
+		}
+	}
+}

From 74cc3deea5e08758cc4226b6d9ade76596b29f17 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:20:11 +0900
Subject: [PATCH 67/82] Code cleanup

---
 src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
index 9af56e2cb..3e0deb847 100644
--- a/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
+++ b/src/MsgPack.Abstraction/Internal/CollectionItemIterator.cs
@@ -2,7 +2,6 @@
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
-using System;
 using System.Buffers;
 using System.Runtime.CompilerServices;
 
@@ -10,7 +9,6 @@ namespace MsgPack.Internal
 {
 	public struct CollectionItemIterator
 	{
-#warning TODO: in SequenceReader<byte> ??
 		public delegate bool CollectionEndDetection(ref SequenceReader<byte> source, ref long nextItemIndex, long itemsCount, out int requestHint);
 
 		private readonly long _itemsCount;
@@ -59,6 +57,7 @@ public void Drain(ref SequenceReader<byte> source)
 			}
 		}
 
+#warning TODO: CancellationToken
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public bool Drain(ref SequenceReader<byte> source, out int requestHint)
 		{

From d6ea8efa8da8abcec02898cf0f0481b968b9ec48 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:21:37 +0900
Subject: [PATCH 68/82] Fix message

---
 .../Internal/FormatDecoder.Primitives.cs      | 385 ++++++------------
 .../Internal/FormatDecoder.Primitives.tt      |  35 +-
 .../Internal/FormatDecoder.Strings.cs         | 102 ++---
 .../Internal/FormatDecoder.Strings.tt         |  34 +-
 4 files changed, 172 insertions(+), 384 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs
index 55630e381..9e7144635 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.cs
@@ -19,14 +19,10 @@ partial class FormatDecoder
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Byte DecodeByte(ref SequenceReader<byte> source)
@@ -49,14 +45,11 @@ public Byte DecodeByte(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Byte DecodeByte(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -64,14 +57,11 @@ public Byte DecodeByte(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Byte? DecodeNullableByte(ref SequenceReader<byte> source)
@@ -94,14 +84,11 @@ public Byte DecodeByte(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Byte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Byte? DecodeNullableByte(ref SequenceReader<byte> source, out int requestHint);
 
@@ -110,14 +97,10 @@ public Byte DecodeByte(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Int16 DecodeInt16(ref SequenceReader<byte> source)
@@ -140,14 +123,11 @@ public Int16 DecodeInt16(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Int16 DecodeInt16(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -155,14 +135,11 @@ public Int16 DecodeInt16(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Int16? DecodeNullableInt16(ref SequenceReader<byte> source)
@@ -185,14 +162,11 @@ public Int16 DecodeInt16(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Int16? DecodeNullableInt16(ref SequenceReader<byte> source, out int requestHint);
 
@@ -201,14 +175,10 @@ public Int16 DecodeInt16(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Int32 DecodeInt32(ref SequenceReader<byte> source)
@@ -231,14 +201,11 @@ public Int32 DecodeInt32(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Int32 DecodeInt32(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -246,14 +213,11 @@ public Int32 DecodeInt32(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Int32? DecodeNullableInt32(ref SequenceReader<byte> source)
@@ -276,14 +240,11 @@ public Int32 DecodeInt32(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Int32? DecodeNullableInt32(ref SequenceReader<byte> source, out int requestHint);
 
@@ -292,14 +253,10 @@ public Int32 DecodeInt32(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Int64 DecodeInt64(ref SequenceReader<byte> source)
@@ -322,14 +279,11 @@ public Int64 DecodeInt64(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Int64 DecodeInt64(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -337,14 +291,11 @@ public Int64 DecodeInt64(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Int64? DecodeNullableInt64(ref SequenceReader<byte> source)
@@ -367,14 +318,11 @@ public Int64 DecodeInt64(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Int64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Int64? DecodeNullableInt64(ref SequenceReader<byte> source, out int requestHint);
 
@@ -383,14 +331,10 @@ public Int64 DecodeInt64(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public SByte DecodeSByte(ref SequenceReader<byte> source)
@@ -413,14 +357,11 @@ public SByte DecodeSByte(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract SByte DecodeSByte(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -428,14 +369,11 @@ public SByte DecodeSByte(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public SByte? DecodeNullableSByte(ref SequenceReader<byte> source)
@@ -458,14 +396,11 @@ public SByte DecodeSByte(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="SByte" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract SByte? DecodeNullableSByte(ref SequenceReader<byte> source, out int requestHint);
 
@@ -474,14 +409,10 @@ public SByte DecodeSByte(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public UInt16 DecodeUInt16(ref SequenceReader<byte> source)
@@ -504,14 +435,11 @@ public UInt16 DecodeUInt16(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract UInt16 DecodeUInt16(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -519,14 +447,11 @@ public UInt16 DecodeUInt16(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public UInt16? DecodeNullableUInt16(ref SequenceReader<byte> source)
@@ -549,14 +474,11 @@ public UInt16 DecodeUInt16(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt16" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract UInt16? DecodeNullableUInt16(ref SequenceReader<byte> source, out int requestHint);
 
@@ -565,14 +487,10 @@ public UInt16 DecodeUInt16(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public UInt32 DecodeUInt32(ref SequenceReader<byte> source)
@@ -595,14 +513,11 @@ public UInt32 DecodeUInt32(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract UInt32 DecodeUInt32(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -610,14 +525,11 @@ public UInt32 DecodeUInt32(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public UInt32? DecodeNullableUInt32(ref SequenceReader<byte> source)
@@ -640,14 +552,11 @@ public UInt32 DecodeUInt32(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt32" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract UInt32? DecodeNullableUInt32(ref SequenceReader<byte> source, out int requestHint);
 
@@ -656,14 +565,10 @@ public UInt32 DecodeUInt32(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public UInt64 DecodeUInt64(ref SequenceReader<byte> source)
@@ -686,14 +591,11 @@ public UInt64 DecodeUInt64(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract UInt64 DecodeUInt64(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -701,14 +603,11 @@ public UInt64 DecodeUInt64(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public UInt64? DecodeNullableUInt64(ref SequenceReader<byte> source)
@@ -731,14 +630,11 @@ public UInt64 DecodeUInt64(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="UInt64" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract UInt64? DecodeNullableUInt64(ref SequenceReader<byte> source, out int requestHint);
 
@@ -747,14 +643,10 @@ public UInt64 DecodeUInt64(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Single DecodeSingle(ref SequenceReader<byte> source)
@@ -777,14 +669,11 @@ public Single DecodeSingle(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Single DecodeSingle(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -792,14 +681,11 @@ public Single DecodeSingle(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Single? DecodeNullableSingle(ref SequenceReader<byte> source)
@@ -822,14 +708,11 @@ public Single DecodeSingle(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Single" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Single? DecodeNullableSingle(ref SequenceReader<byte> source, out int requestHint);
 
@@ -838,14 +721,10 @@ public Single DecodeSingle(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Double DecodeDouble(ref SequenceReader<byte> source)
@@ -868,14 +747,11 @@ public Double DecodeDouble(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Double DecodeDouble(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -883,14 +759,11 @@ public Double DecodeDouble(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Double? DecodeNullableDouble(ref SequenceReader<byte> source)
@@ -913,14 +786,11 @@ public Double DecodeDouble(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Double" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Double? DecodeNullableDouble(ref SequenceReader<byte> source, out int requestHint);
 
@@ -929,14 +799,10 @@ public Double DecodeDouble(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Boolean DecodeBoolean(ref SequenceReader<byte> source)
@@ -959,14 +825,11 @@ public Boolean DecodeBoolean(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Boolean DecodeBoolean(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -974,14 +837,11 @@ public Boolean DecodeBoolean(ref SequenceReader<byte> source)
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Boolean? DecodeNullableBoolean(ref SequenceReader<byte> source)
@@ -1004,14 +864,11 @@ public Boolean DecodeBoolean(ref SequenceReader<byte> source)
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Boolean" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Boolean? DecodeNullableBoolean(ref SequenceReader<byte> source, out int requestHint);
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt
index 3eb211dcd..f31bf57a4 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Primitives.tt
@@ -37,14 +37,10 @@ foreach (var outputType in new [] {
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public <#= outputType #> Decode<#= outputType #>(ref SequenceReader<byte> source)
@@ -67,14 +63,11 @@ foreach (var outputType in new [] {
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract <#= outputType #> Decode<#= outputType #>(ref SequenceReader<byte> source, out int requestHint);
 
 		/// <summary>
@@ -82,14 +75,11 @@ foreach (var outputType in new [] {
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public <#= outputType #>? DecodeNullable<#= outputType #>(ref SequenceReader<byte> source)
@@ -112,14 +102,11 @@ foreach (var outputType in new [] {
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= outputType #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract <#= outputType #>? DecodeNullable<#= outputType #>(ref SequenceReader<byte> source, out int requestHint);
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
index 0bdc088f8..dc7897071 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
@@ -25,14 +25,10 @@ partial class FormatDecoder
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
@@ -57,14 +53,11 @@ public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding =
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract String? DecodeString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 		/// <summary>
@@ -73,14 +66,10 @@ public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding =
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public String? DecodeNullableString(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
@@ -104,14 +93,11 @@ public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding =
 		/// </param>
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract String? DecodeNullableString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
@@ -125,14 +111,10 @@ public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding =
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
@@ -157,14 +139,11 @@ public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? en
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract Utf8String? DecodeUtf8String(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
 		/// <summary>
@@ -173,14 +152,10 @@ public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? en
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public Utf8String? DecodeNullableUtf8String(ref SequenceReader<byte> source, Encoding? encoding = null, CancellationToken cancellationToken = default)
@@ -204,14 +179,11 @@ public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? en
 		/// </param>
 		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Utf8String? DecodeNullableUtf8String(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
@@ -224,14 +196,10 @@ public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? en
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public byte[] DecodeBinary(ref SequenceReader<byte> source, CancellationToken cancellationToken = default)
@@ -255,14 +223,11 @@ public byte[] DecodeBinary(ref SequenceReader<byte> source, CancellationToken ca
 		/// </param>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract byte[]? DecodeBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
 
 		/// <summary>
@@ -270,14 +235,10 @@ public byte[] DecodeBinary(ref SequenceReader<byte> source, CancellationToken ca
 		/// </summary>
 		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, CancellationToken cancellationToken = default)
@@ -300,14 +261,11 @@ public byte[] DecodeBinary(ref SequenceReader<byte> source, CancellationToken ca
 		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
 		/// </param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
 
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
index 5f4feaaf5..de5b0ea37 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
@@ -68,14 +68,10 @@ foreach (var spec in new [] {
 #>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public <#= spec.Type #> Decode<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
@@ -107,14 +103,11 @@ foreach (var spec in new [] {
 #>
 		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		public abstract <#= spec.Type #>? Decode<#= spec.Name #>(ref SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
 
 		/// <summary>
@@ -130,14 +123,10 @@ foreach (var spec in new [] {
 	}
 #>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public <#= spec.Type #>? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
@@ -168,14 +157,11 @@ foreach (var spec in new [] {
 	}
 #>
 		/// <return>
-		///		Decoded value if this method succeeds to decode value; Default value when <paramref name="source" /> does not contain enough bytes to decode.
-		///		If this value is default, <paramref name="source" /> will not be advanced.
+		///		Decoded value if this method succeeds to decode value.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
 		/// </return>
-		/// <remarks>
-		///		The caller must concatinate old remaining sequence and new sequence when this method returns <c>false</c> and then recall.
-		/// </remarks>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
 		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
-		/// <exception cref="NotSupportedException">The underlying format does not suppor this type.</exception>
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract <#= spec.Type #>? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
 

From 0c7c0fa1a965d860b81256f1cac2dfb2219adfc8 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:22:36 +0900
Subject: [PATCH 69/82] Add DecodeItem(..., out int requestHint, ...)

This is required to implement some built-in serializers.
---
 src/MsgPack.Abstraction/Internal/FormatDecoder.cs | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
index 632f3f7cc..684ea87ef 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.cs
@@ -9,8 +9,6 @@
 
 namespace MsgPack.Internal
 {
-#warning TODO: Use 'Try' prefix for published APIs which can return 'requestHint'.
-
 	/// <summary>
 	///		Defines an interface and basic functionarity of stateless <see cref="FormatDecoder"/>.
 	/// </summary>
@@ -38,7 +36,16 @@ public void Skip(ref SequenceReader<byte> source, in CollectionContext collectio
 
 		public abstract void Skip(ref SequenceReader<byte> source, in CollectionContext collectionContext, out int requestHint, CancellationToken cancellationToken = default);
 
-		public abstract bool DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default);
+		public void DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult result, CancellationToken cancellationToken = default)
+		{
+			this.DecodeItem(ref source, out result, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForAnyItem(source.Consumed, requestHint);
+			}
+		}
+
+		public abstract void DecodeItem(ref SequenceReader<byte> source, out DecodeItemResult result, out int requestHint, CancellationToken cancellationToken = default);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public void GetRawString(ref SequenceReader<byte> source, out ReadOnlySpan<byte> rawString, CancellationToken cancellationToken = default)

From 9669443ef4152297ac30b726fb48f300188ce691 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:24:01 +0900
Subject: [PATCH 70/82] Add span based Decode overload

These are needed to implement efficient polymorphic support.
These also should be wanted by data with fixed length string/binary.
---
 .../Internal/FormatDecoder.Strings.cs         | 275 ++++++++++++++++++
 .../Internal/FormatDecoder.Strings.tt         | 127 +++++++-
 2 files changed, 399 insertions(+), 3 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
index dc7897071..87f7ad1e5 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.cs
@@ -101,6 +101,99 @@ public String DecodeString(ref SequenceReader<byte> source, Encoding? encoding =
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract String? DecodeNullableString(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		///		Decodes the value from specified sequence to <see cref="Span{T}" /> of <see cref="Char" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Char" /> which will store the decoded binary.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int DecodeString(ref SequenceReader<byte> source, Span<char> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeString(ref source, buffer, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForString(source.Consumed, typeof(String), encoding, requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes the value from specified sequence to <see cref="Span{T}" /> of <see cref="Char" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Char" /> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		public abstract int DecodeString(ref SequenceReader<byte> source, Span<char> buffer, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <see cref="Span{T}" /> of <see cref="Char" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Char" /> which will store the decoded binary.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int? DecodeNullableString(ref SequenceReader<byte> source, Span<char> buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullableString(ref source, buffer, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForString(source.Consumed, typeof(String), encoding, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <see cref="Span{T}" /> of <see cref="Char" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Char" /> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="String" /> type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract int? DecodeNullableString(ref SequenceReader<byte> source, Span<char> buffer, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
 
 #if FEATURE_UTF8STRING
 
@@ -187,6 +280,99 @@ public Utf8String DecodeUtf8String(ref SequenceReader<byte> source, Encoding? en
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract Utf8String? DecodeNullableUtf8String(ref SequenceReader<byte> source, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		///		Decodes the value from specified sequence to <see cref="Utf8Span" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Utf8Span" /> which will store the decoded binary.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int DecodeUtf8String(ref SequenceReader<byte> source, Utf8Span buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeUtf8String(ref source, buffer, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForUtf8String(source.Consumed, typeof(Utf8String), encoding, requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes the value from specified sequence to <see cref="Utf8Span" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Utf8Span" /> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		public abstract int DecodeUtf8String(ref SequenceReader<byte> source, Utf8Span buffer, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <see cref="Utf8Span" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Utf8Span" /> which will store the decoded binary.</param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int? DecodeNullableUtf8String(ref SequenceReader<byte> source, Utf8Span buffer, Encoding? encoding = null, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullableUtf8String(ref source, buffer, out var requestHint, encoding, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInputForUtf8String(source.Consumed, typeof(Utf8String), encoding, requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <see cref="Utf8Span" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Utf8Span" /> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="encoding">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="Utf8String" /> type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract int? DecodeNullableUtf8String(ref SequenceReader<byte> source, Utf8Span buffer, out int requestHint, Encoding? encoding = null, CancellationToken cancellationToken = default);
+
 
 #endif // FEATURE_UTF8STRING
 
@@ -269,5 +455,94 @@ public byte[] DecodeBinary(ref SequenceReader<byte> source, CancellationToken ca
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract byte[]? DecodeNullableBinary(ref SequenceReader<byte> source, out int requestHint, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		///		Decodes the value from specified sequence to <see cref="Span{T}" /> of <see cref="Byte" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Byte" /> which will store the decoded binary.</param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int DecodeBinary(ref SequenceReader<byte> source, Span<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeBinary(ref source, buffer, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(byte[]), requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes the value from specified sequence to <see cref="Span{T}" /> of <see cref="Byte" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Byte" /> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		public abstract int DecodeBinary(ref SequenceReader<byte> source, Span<byte> buffer, out int requestHint, CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <see cref="Span{T}" /> of <see cref="Byte" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Byte" /> which will store the decoded binary.</param>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int? DecodeNullableBinary(ref SequenceReader<byte> source, Span<byte> buffer, CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullableBinary(ref source, buffer, out var requestHint, cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput(source.Consumed, typeof(byte[]), requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <see cref="Span{T}" /> of <see cref="Byte" />.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><see cref="Span{T}" /> of <see cref="Byte" /> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="byte[]" /> type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract int? DecodeNullableBinary(ref SequenceReader<byte> source, Span<byte> buffer, out int requestHint, CancellationToken cancellationToken = default);
+
 	}
 }
diff --git a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
index de5b0ea37..b949abac6 100644
--- a/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
+++ b/src/MsgPack.Abstraction/Internal/FormatDecoder.Strings.tt
@@ -24,21 +24,21 @@ namespace MsgPack.Internal
 foreach (var spec in new [] {
 	new
 	{
-		Name = "String", Type = "String", ThrowSuffix = "ForString",
+		Name = "String", Type = "String", SpanType = "Span<char>", ThrowSuffix = "ForString", SpanTypeDoc = "<see cref=\"Span{T}\" /> of <see cref=\"Char\" />",
 		ExtraParameters = "Encoding? encoding = null, ",
 		ExtraParameterDocs = new [] { "<param name=\"encoding\">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>" },
 		ExtraArguments = "encoding, ", IfDef = String.Empty
 	},
 	new
 	{
-		Name = "Utf8String", Type = "Utf8String", ThrowSuffix = "ForUtf8String",
+		Name = "Utf8String", Type = "Utf8String", SpanType = "Utf8Span", ThrowSuffix = "ForUtf8String", SpanTypeDoc = "<see cref=\"Utf8Span\" />",
 		ExtraParameters = "Encoding? encoding = null, ",
 		ExtraParameterDocs = new [] { "<param name=\"encoding\">Specify charactor encoding. This value can be omitted, and default is UTF-8 without BOM.</param>" },
 		ExtraArguments = "encoding, ", IfDef = "FEATURE_UTF8STRING"
 	},
 	new
 	{
-		Name = "Binary", Type = "byte[]", ThrowSuffix = String.Empty,
+		Name = "Binary", Type = "byte[]", SpanType = "Span<byte>", ThrowSuffix = String.Empty, SpanTypeDoc = "<see cref=\"Span{T}\" /> of <see cref=\"Byte\" />",
 		ExtraParameters = String.Empty,
 		ExtraParameterDocs = Array.Empty<string>(),
 		ExtraArguments = String.Empty, IfDef = String.Empty
@@ -165,6 +165,127 @@ foreach (var spec in new [] {
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
 		public abstract <#= spec.Type #>? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
 
+		/// <summary>
+		///		Decodes the value from specified sequence to <#= spec.SpanTypeDoc #>.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><#= spec.SpanTypeDoc #> which will store the decoded binary.</param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int Decode<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.SpanType #> buffer, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
+		{
+			var result = this.Decode<#= spec.Name #>(ref source, buffer, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput<#= spec.ThrowSuffix #>(source.Consumed, typeof(<#= spec.Type #>), <#= spec.ExtraArguments #>requestHint);
+			}
+
+			return result!;
+		}
+
+		/// <summary>
+		///		Decodes the value from specified sequence to <#= spec.SpanTypeDoc #>.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><#= spec.SpanTypeDoc #> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <param name="cacellationToken"><see cref="CancellationToken" /> to cancel long running operation. This value can be omitted.</param>
+		/// <return>
+		///		The length of the decoded value.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		public abstract int Decode<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.SpanType #> buffer, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <#= spec.SpanTypeDoc #>.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><#= spec.SpanTypeDoc #> which will store the decoded binary.</param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		///	<exception cref="InsufficientInputException"><paramref name="source"/> does not contain enough bytes to decode.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public int? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.SpanType #> buffer, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default)
+		{
+			var result = this.DecodeNullable<#= spec.Name #>(ref source, buffer, out var requestHint, <#= spec.ExtraArguments #>cancellationToken);
+			if (requestHint != 0)
+			{
+				Throw.InsufficientInput<#= spec.ThrowSuffix #>(source.Consumed, typeof(<#= spec.Type #>), <#= spec.ExtraArguments #>requestHint);
+			}
+
+			return result;
+		}
+
+		/// <summary>
+		///		Decodes the value or <c>null</c> from specified sequence to <#= spec.SpanTypeDoc #>.
+		/// </summary>
+		/// <param name="source"><see cref="SequenceReader{T}">SequenceReader&lt;byte&gt;</see>.</param>
+		/// <param name="buffer"><#= spec.SpanTypeDoc #> which will store the decoded binary.</param>
+		/// <param name="requestHint">
+		///		<c>0</c> if this method succeeds to decode value; Positive integer when <paramref name="source" /> does not contain enough bytes to decode, and required memory bytes hint is stored.
+		///		Note that <c>-1</c> represents unknown size. If so, caller must supply new buffer with most efficient size.
+		/// </param>
+<#
+	foreach (var doc in spec.ExtraParameterDocs)
+	{
+#>
+		/// <#= doc #>
+<#
+	}
+#>
+		/// <return>
+		///		The length of the decoded value;
+		///		<c>null</c> when the underlying value is <c>null</c>.
+		///		This value can be <c>0</c> for empty string.
+		///		Note that the value of this return is not defined when <paramref name="requestHint" /> is <c>0</c>. 
+		/// </return>
+		/// <exception cref="MessageFormatException"><paramref name="source"/> contains valid byte sequence for the underlying format.</exception>
+		/// <exception cref="MessageTypeException">The underlying format value is not compatible to <see cref="<#= spec.Type #>" /> type.</exception>
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public abstract int? DecodeNullable<#= spec.Name #>(ref SequenceReader<byte> source, <#= spec.SpanType #> buffer, out int requestHint, <#= spec.ExtraParameters #>CancellationToken cancellationToken = default);
+
 <#
 	if (!String.IsNullOrEmpty(spec.IfDef))
 	{

From f76d5c4dcaab10bdb7124b146b78494d46d6e490 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:29:09 +0900
Subject: [PATCH 71/82] TODO REVISE Fix DecodeItemResult ext type handling

NOTE where is MessagePackDecoder.Extension fix??
---
 .../Internal/DecodeItemResult.cs              | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs b/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
index 1f1ef3a51..9f8ac3fd9 100644
--- a/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
+++ b/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
@@ -8,6 +8,7 @@
 
 namespace MsgPack.Internal
 {
+#warning TODO: Decode -> Parse, Encode -> Format
 	/// <summary>
 	///		Represents a result of <see cref="FormatDecoder.DecodeItem"/>.
 	/// </summary>
@@ -15,28 +16,27 @@ public readonly struct DecodeItemResult
 	{
 		public bool HasValue => this.ElementType != ElementType.None;
 		public ElementType ElementType { get; }
+
+		// If ElementType is string , this value is not decoded.
 		public ReadOnlySequence<byte> Value { get; }
 		public CollectionItemIterator CollectionIterator { get; }
 		public long CollectionLength { get; }
-		public ExtensionTypeObject ExtensionTypeObject { get; }
+		public ExtensionType ExtensionType { get; }
 		public ReadOnlySequence<byte> ExtensionBody => this.Value;
-		public long RequestHint { get; }
 
 		private DecodeItemResult(
 			ElementType elementType,
 			in ReadOnlySequence<byte> value = default,
 			in CollectionItemIterator collectionIterator = default,
 			long collectionLength = default,
-			ExtensionTypeObject extensionTypeObject = default,
-			long requestHint = default
+			ExtensionType extensionType = default
 		)
 		{
 			this.ElementType = elementType;
 			this.Value = value;
 			this.CollectionIterator = collectionIterator;
 			this.CollectionLength = collectionLength;
-			this.ExtensionTypeObject = extensionTypeObject;
-			this.RequestHint = requestHint;
+			this.ExtensionType = extensionType;
 		}
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
@@ -64,11 +64,13 @@ public static DecodeItemResult False()
 			=> new DecodeItemResult(ElementType.False);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult ExtensionType(ExtensionTypeObject extensionTypeObject)
-			=> new DecodeItemResult(ElementType.Extension, extensionTypeObject : extensionTypeObject);
+		public static DecodeItemResult ExtensionTypeObject(ExtensionType extensionType, in ReadOnlySequence<byte> body)
+			=> new DecodeItemResult(ElementType.Extension, extensionType: extensionType, value: body);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult InsufficientInput()
+			=> new DecodeItemResult(ElementType.None);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
-		public static DecodeItemResult InsufficientInput(long requestHint)
-			=> new DecodeItemResult(ElementType.None, requestHint: requestHint);
 	}
 }

From 3acbc76538ff038c78d71f2a8cc0d6659972f793 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:29:49 +0900
Subject: [PATCH 72/82] Add DecodeItemResult.EndOfStream

---
 src/MsgPack.Abstraction/Internal/DecodeItemResult.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs b/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
index 9f8ac3fd9..67ca604f3 100644
--- a/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
+++ b/src/MsgPack.Abstraction/Internal/DecodeItemResult.cs
@@ -72,5 +72,7 @@ public static DecodeItemResult InsufficientInput()
 			=> new DecodeItemResult(ElementType.None);
 
 		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static DecodeItemResult EndOfStream()
+			=> new DecodeItemResult(ElementType.None);
 	}
 }

From 48eeb1c0bb58e9d3ee5cc6c67f69c23f3351132d Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:30:09 +0900
Subject: [PATCH 73/82] Add more throws

---
 src/MsgPack.Abstraction/StringEscape.cs | 165 ++++++++++++++++++++++++
 src/MsgPack.Abstraction/Throw.cs        |  88 ++++++++-----
 2 files changed, 220 insertions(+), 33 deletions(-)
 create mode 100644 src/MsgPack.Abstraction/StringEscape.cs

diff --git a/src/MsgPack.Abstraction/StringEscape.cs b/src/MsgPack.Abstraction/StringEscape.cs
new file mode 100644
index 000000000..8e1dc7b4b
--- /dev/null
+++ b/src/MsgPack.Abstraction/StringEscape.cs
@@ -0,0 +1,165 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+#warning TODO: Move to Common/
+
+using System;
+using System.Buffers;
+using System.Globalization;
+using System.Text;
+
+namespace MsgPack
+{
+	internal static class StringEscape
+	{
+		public static string ForDisplay(string value)
+		{
+			if (value == null)
+			{
+				return String.Empty;
+			}
+
+			var buffer = new StringBuilder();
+			foreach (Rune r in value.EnumerateRunes())
+			{
+				if (buffer.Length > 64)
+				{
+					buffer.Append("...");
+					break;
+				}
+
+				switch (r.Value)
+				{
+					case '\0':
+					{
+						buffer.Append("\\0");
+						continue;
+					}
+					case '\t':
+					{
+						buffer.Append("\\t");
+						continue;
+					}
+					case '\r':
+					{
+						buffer.Append("\\r");
+						continue;
+					}
+					case '\n':
+					{
+						buffer.Append("\\n");
+						continue;
+					}
+					case '\a':
+					{
+						buffer.Append("\\a");
+						continue;
+					}
+					case '\b':
+					{
+						buffer.Append("\\b");
+						continue;
+					}
+					case '\f':
+					{
+						buffer.Append("\\f");
+						continue;
+					}
+					case '\v':
+					{
+						buffer.Append("\\v");
+						continue;
+					}
+					case '\\':
+					{
+						buffer.Append("\\\\");
+						continue;
+					}
+					case ' ':
+					{
+						buffer.Append(' ');
+						continue;
+					}
+				}
+
+				switch (Rune.GetUnicodeCategory(r))
+				{
+					case UnicodeCategory.Control:
+					case UnicodeCategory.Format:
+					case UnicodeCategory.LineSeparator:
+					case UnicodeCategory.ModifierLetter:
+					case UnicodeCategory.ModifierSymbol:
+					case UnicodeCategory.NonSpacingMark:
+					case UnicodeCategory.OtherNotAssigned:
+					case UnicodeCategory.ParagraphSeparator:
+					case UnicodeCategory.SpacingCombiningMark:
+					case UnicodeCategory.Surrogate:
+					case UnicodeCategory.PrivateUse:
+					{
+						if (r.Value == ' ')
+						{
+							goto default;
+						}
+
+						buffer.Append("\\u").Append((r.Value).ToString("X4", CultureInfo.InvariantCulture));
+						continue;
+					}
+					default:
+					{
+						Span<char> c = stackalloc char[2];
+						r.TryEncodeToUtf16(c, out var charsWritten);
+						buffer.Append(c.Slice(0, charsWritten));
+						continue;
+					}
+				}
+			}
+
+			return buffer.ToString();
+		}
+
+		public static string Stringify(in ReadOnlySequence<byte> unit)
+		{
+			var buffer = new StringBuilder();
+			foreach (var rune in Encoding.UTF8.GetString(unit.Slice(0, 260).ToArray()).EnumerateRunes())
+			{
+				if (buffer.Length > 64)
+				{
+					buffer.Append("...");
+					break;
+				}
+
+				var category = Rune.GetUnicodeCategory(rune);
+				switch (category)
+				{
+					case UnicodeCategory.Control:
+					case UnicodeCategory.Format:
+					case UnicodeCategory.LineSeparator:
+					case UnicodeCategory.ModifierLetter:
+					case UnicodeCategory.ModifierSymbol:
+					case UnicodeCategory.NonSpacingMark:
+					case UnicodeCategory.OtherNotAssigned:
+					case UnicodeCategory.ParagraphSeparator:
+					case UnicodeCategory.SpacingCombiningMark:
+					case UnicodeCategory.Surrogate:
+					{
+						buffer.Append($"<control-charactor>(U+{rune.Value:X4}, {category})");
+						break;
+					}
+					case UnicodeCategory.SpaceSeparator:
+					{
+						buffer.Append($"'{rune}'(U+{rune.Value:X4}, {category})");
+						break;
+					}
+					default:
+					{
+						buffer.Append('\'').Append(rune).Append('\'');
+						break;
+					}
+				}
+			}
+
+			return buffer.ToString();
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Throw.cs b/src/MsgPack.Abstraction/Throw.cs
index 7e86a40d0..d450d8583 100644
--- a/src/MsgPack.Abstraction/Throw.cs
+++ b/src/MsgPack.Abstraction/Throw.cs
@@ -3,10 +3,9 @@
 // See the LICENSE in the project root for more information.
 
 using System;
-using System.Runtime.Serialization;
+using System.Runtime.CompilerServices;
 using System.Text;
 using MsgPack.Internal;
-using MsgPack.Serialization;
 
 namespace MsgPack
 {
@@ -14,6 +13,14 @@ internal static class Throw
 	{
 		public static void ObjectDisposed(string? name)
 			=> throw new ObjectDisposedException(name);
+		public static char? InvalidIso8601DecimalSeparator(char? value, [CallerArgumentExpression("value")] string paramName = null!)
+			=> throw new ArgumentOutOfRangeException(paramName, $"Value '{StringEscape.ForDisplay(value.GetValueOrDefault().ToString())}' is not valid ISO 8601 decimal separator.");
+
+		public static void CannotBeNilAs<T>()
+			=> throw new InvalidOperationException($"Nil value cannot be converted to '{typeof(T)}' value.");
+
+		public static void InvalidTypeAs<T>(MessagePackObject obj)
+			=> throw new InvalidOperationException($"'{obj}' cannot be converted to '{typeof(T)}' value.");
 
 		public static void ExtensionsIsNotSupported()
 			=> throw new NotSupportedException($"Extension type is not supported in this encoder.");
@@ -31,13 +38,13 @@ public static void EmptyObject(Type type)
 			=> throw new InvalidOperationException($"Cannot use empty '{type}' object.");
 
 		public static void DepthExeeded(long position, int maxDepth)
-			=> throw new LimitExceededException($"The depth of collection exceeds max depth {maxDepth:#,0} at {position:#,0}.");
+			=> throw new LimitExceededException(position, $"The depth of collection exceeds max depth {maxDepth:#,0}.");
 
 		public static void StringLengthExceeded(long position, long length, int maxLength)
-			=> throw new LimitExceededException($"The byte length of encoded string ({length:#,0}) exceeds max length ({maxLength:#,0}) at {position:#,0}.");
+			=> throw new LimitExceededException(position, $"The byte length of encoded string ({length:#,0}) exceeds max length ({maxLength:#,0}).");
 
 		public static void BinaryLengthExceeded(long position, long length, int maxLength)
-			=> throw new LimitExceededException($"The byte length of encoded binary ({length:#,0}) exceeds max length ({maxLength:#,0}) at {position:#,0}.");
+			=> throw new LimitExceededException(position, $"The byte length of encoded binary ({length:#,0}) exceeds max length ({maxLength:#,0}).");
 
 		public static void DepthUnderflow()
 			=> throw new InvalidOperationException("CurrentDepth is 0.");
@@ -49,17 +56,29 @@ public static void TooLargeByteLength(Exception innerException, string encodingN
 			=> throw new InvalidOperationException($"Input ReadOnlySequence is too large. It will be encoded to larger than {Int32.MaxValue:#,0} bytes with '{encodingName}' encoding, but it must be less than or equal to {UInt32.MaxValue:#,0} bytes.", innerException);
 
 		public static void TooLargePropertyKey(long position, int length, int maxPropertyKeyLength)
-			=> throw new InvalidOperationException($"Property key is too large. The size {length:#,0} is larger than configured limit {maxPropertyKeyLength:#,0} at {position:#,0}.");
+			=> throw new LimitExceededException(position, $"Property key is too large. The size {length:#,0} is larger than configured limit {maxPropertyKeyLength:#,0}.");
 
 		public static void InsufficientInput(long position, Type targetType, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode {targetType} value at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode {targetType} value.");
+			}
+			else
+			{
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode {targetType} value.");
+			}
+		}
+
+		public static void InsufficientInputForAnyItem(long position, int requestHint)
+		{
+			if (requestHint < 0)
+			{
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode any value.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode {targetType} value at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode any value.");
 			}
 		}
 
@@ -67,11 +86,11 @@ public static void InsufficientInputForNull(long position, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode null at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode null.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode null at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode null.");
 			}
 		}
 
@@ -80,41 +99,35 @@ public static void InsufficientInputForDecodeArrayOrMapHeader(long position, int
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode array or map header at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode array or map header.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode array or map header at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode array or map header.");
 			}
 		}
 
-		public static void CannotBeNull(Type type)
-			 => throw new SerializationException($"Value of type '{type}' cannot be null.");
-
 		public static void InsufficientInputForDecodeArrayHeader(long position, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode array header at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode array header.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode array header at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode array header.");
 			}
 		}
 
-		public static void UnavailableMethod(string name, SerializationMethod array)
-			=> throw new NotSupportedException($"SerializationMethod '{array}' is not supported in '{name}' format.");
-
 		public static void InsufficientInputForDecodeMapHeader(long position, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode map header at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode map header.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode map header at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode map header.");
 			}
 		}
 
@@ -122,11 +135,11 @@ public static void InsufficientInputForString(long position, Type type, Encoding
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to decode string as {type} with '{encoding}' encoding at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to decode string as {type} with '{encoding}' encoding.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode string as {type} with '{encoding}' encoding at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to decode string as {type} with '{encoding}' encoding.");
 			}
 		}
 
@@ -134,11 +147,11 @@ public static void InsufficientInputForRawString(long position, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to fetch raw string at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to fetch raw string.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to fetch raw string at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to fetch raw string.");
 			}
 		}
 
@@ -146,11 +159,11 @@ public static void InsufficientInputForSkip(long position, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to skip current subtree at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to skip current subtree.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to skip current subtree at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to skip current subtree.");
 			}
 		}
 
@@ -158,24 +171,33 @@ public static void InsufficientInputForDetectCollectionEnds(long position, int r
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to detect whether current collection is end at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to detect whether current collection is end.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to detect whether current collection is end at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to detect whether current collection is end.");
 			}
 		}
 
-		internal static void InsufficientInputForDrainCollectionItems(long position, int requestHint)
+		public static void InsufficientInputForDrainCollectionItems(long position, int requestHint)
 		{
 			if (requestHint < 0)
 			{
-				throw new InsufficientInputException($"It is required more bytes in input ReadOnlySequence to drain current collection items at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more bytes in input ReadOnlySequence to drain current collection items.");
 			}
 			else
 			{
-				throw new InsufficientInputException($"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to current collection items at {position:#,0}.");
+				throw new InsufficientInputException(position, $"It is required more {requestHint:#,0} bytes in input ReadOnlySequence to current collection items.");
 			}
 		}
+
+		public static void InvalidTimestampLength(long length, string paramName)
+			=> throw new ArgumentException($"The value's length {length} bytes is not valid. It should be 4, 8, or 12 bytes.", paramName);
+
+		public static void InvalidTimestampTypeCode(byte tag, string paramName)
+			=> throw new ArgumentException($"Timestamp must have type code -1 (0xFF in byte), but actual value is {unchecked((sbyte)tag)}(0x{tag:x}).", paramName);
+
+		public static void InvalidTimestampTypeCode(long tag, string paramName)
+			=> throw new ArgumentException($"Timestamp must have type code -1 (0xFF in byte), but actual value is {tag}(0x{tag:x}).", paramName);
 	}
 }

From d3e4e7f65097d40ccc22ff0a43c7028f82a09729 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:30:23 +0900
Subject: [PATCH 74/82] Clarify property name

---
 src/MsgPack.Abstraction/Internal/OptionsDefaults.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
index 84ddac7cf..bdb6492ba 100644
--- a/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
+++ b/src/MsgPack.Abstraction/Internal/OptionsDefaults.cs
@@ -25,7 +25,7 @@ internal static class OptionsDefaults
 		public static readonly int MaxDepth = 100;
 		public static readonly ArrayPool<byte> ByteBufferPool = ArrayPool<byte>.Shared;
 		public static readonly ArrayPool<char> CharBufferPool = ArrayPool<char>.Shared;
-		public static readonly bool ClearsBuffer = true;
+		public static readonly bool ClearsBufferOnReturn = false;
 		public static readonly bool CanTreatRealAsInteger = true;
 		public static readonly SerializationMethod? PreferredSerializationMethod = null;
 	}

From 9684ef72c47a0f15e658d4448321e71b993d9abf Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:31:09 +0900
Subject: [PATCH 75/82] Add CodecProvider to configure serializer codec

---
 .../Codecs/CodecProvider.cs                   | 31 +++++++++++++++
 .../Codecs/MessagePackCodecProvider.cs        | 39 +++++++++++++++++++
 .../Codecs.Json/JsonCodecProvider.cs          | 36 +++++++++++++++++
 3 files changed, 106 insertions(+)
 create mode 100644 src/MsgPack.Abstraction/Codecs/CodecProvider.cs
 create mode 100644 src/MsgPack.Core/Codecs/MessagePackCodecProvider.cs
 create mode 100644 src/MsgPack.Json/Codecs.Json/JsonCodecProvider.cs

diff --git a/src/MsgPack.Abstraction/Codecs/CodecProvider.cs b/src/MsgPack.Abstraction/Codecs/CodecProvider.cs
new file mode 100644
index 000000000..be9460ee4
--- /dev/null
+++ b/src/MsgPack.Abstraction/Codecs/CodecProvider.cs
@@ -0,0 +1,31 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Codecs
+{
+	/// <summary>
+	///		Defines basic features and interfaces of codec provider which provides encoder and decoder.
+	/// </summary>
+	public abstract class CodecProvider 
+	{
+		/// <summary>
+		///		Initializes a new instance of <see cref="CodecProvider"/> object.
+		/// </summary>
+		protected CodecProvider() { }
+
+		/// <summary>
+		///		Gets an instance of <see cref="FormatEncoder"/> object.
+		/// </summary>
+		/// <returns>An instance of <see cref="FormatEncoder"/> object.</returns>
+		public abstract FormatEncoder GetEncoder();
+
+		/// <summary>
+		///		Gets an instance of <see cref="FormatDecoder"/> object.
+		/// </summary>
+		/// <returns>An instance of <see cref="FormatDecoder"/> object.</returns>
+		public abstract FormatDecoder GetDecoder();
+	}
+}
diff --git a/src/MsgPack.Core/Codecs/MessagePackCodecProvider.cs b/src/MsgPack.Core/Codecs/MessagePackCodecProvider.cs
new file mode 100644
index 000000000..073430a39
--- /dev/null
+++ b/src/MsgPack.Core/Codecs/MessagePackCodecProvider.cs
@@ -0,0 +1,39 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+
+namespace MsgPack.Codecs
+{
+	public sealed class MessagePackCodecProvider : CodecProvider
+	{
+		public static MessagePackCodecProvider Default { get; } = new MessagePackCodecProvider(MessagePackEncoderOptions.Default, MessagePackDecoderOptions.Default);
+
+		private readonly MessagePackEncoder _encoder;
+		private readonly MessagePackDecoder _decoder;
+
+		public MessagePackCodecProvider(
+			MessagePackEncoderOptions encoderOptions, 
+			MessagePackDecoderOptions decoderOptions,
+			MessagePackCompatibilityLevel compatibilityLevel = MessagePackCompatibilityLevel.Latest
+		)
+		{
+			if (compatibilityLevel == MessagePackCompatibilityLevel.Version2008)
+			{
+				this._encoder = new LegacyMessagePackEncoder(encoderOptions);
+			}
+			else
+			{
+				this._encoder = new CurrentMessagePackEncoder(encoderOptions);
+			}
+
+			this._decoder = new MessagePackDecoder(decoderOptions);
+		}
+
+		public sealed override FormatEncoder GetEncoder() => this._encoder;
+
+		public sealed override FormatDecoder GetDecoder() => this._decoder;
+
+	}
+}
diff --git a/src/MsgPack.Json/Codecs.Json/JsonCodecProvider.cs b/src/MsgPack.Json/Codecs.Json/JsonCodecProvider.cs
new file mode 100644
index 000000000..90dc6274c
--- /dev/null
+++ b/src/MsgPack.Json/Codecs.Json/JsonCodecProvider.cs
@@ -0,0 +1,36 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Internal;
+using MsgPack.Json;
+
+namespace MsgPack.Codecs
+{
+	public sealed class JsonCodecProvider : CodecProvider
+	{
+		private readonly JsonEncoder _encoder;
+		private readonly JsonDecoder _decoder;
+
+		public JsonCodecProvider(
+			JsonEncoderOptions encoderOptions, 
+			JsonDecoderOptions decoderOptions
+		)
+		{
+			this._encoder = new JsonEncoder(Ensure.NotNull(encoderOptions));
+			Ensure.NotNull(decoderOptions);
+			if (decoderOptions.ParseOptions == JsonParseOptions.None)
+			{
+				this._decoder = new SimpleJsonDecoder(decoderOptions);
+			}
+			else
+			{
+				this._decoder = new FlexibleJsonDecoder(decoderOptions);
+			}
+		}
+
+		public sealed override FormatEncoder GetEncoder() => this._encoder;
+
+		public sealed override FormatDecoder GetDecoder() => this._decoder;
+	}
+}

From 58fee4845942c390a9180224acc99c164ad66c62 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:33:05 +0900
Subject: [PATCH 76/82] FIX porting primitive types

---
 src/MsgPack/SetOperation.cs                   | 213 +++++-------------
 src/MsgPack/Timestamp.Conversion.cs           |  64 +++---
 src/MsgPack/Timestamp.ParseExact.cs           |  82 +++----
 src/MsgPack/Timestamp.Properties.cs           | 190 +++++++---------
 src/MsgPack/Timestamp.ToString.cs             |  18 +-
 src/MsgPack/Timestamp.TryParseExact.cs        |  99 +++-----
 src/MsgPack/Timestamp.cs                      |  80 +++----
 src/MsgPack/TimestampParseResult.cs           |  33 +--
 src/MsgPack/TimestampStringConverter.Parse.cs | 198 ++++++++--------
 .../TimestampStringConverter.ToString.cs      |  70 +++---
 src/MsgPack/TimestampStringConverter.cs       |  36 +--
 11 files changed, 410 insertions(+), 673 deletions(-)

diff --git a/src/MsgPack/SetOperation.cs b/src/MsgPack/SetOperation.cs
index fb01401fd..630af3c48 100644
--- a/src/MsgPack/SetOperation.cs
+++ b/src/MsgPack/SetOperation.cs
@@ -1,38 +1,11 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
-#if !UNITY
-using System;
 using System.Collections.Generic;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 using System.Linq;
 
-
 namespace MsgPack
 {
 	/// <summary>
@@ -40,38 +13,29 @@ namespace MsgPack
 	/// </summary>
 	internal static class SetOperation
 	{
-		[Pure]
 #if NET35
-		public static bool IsProperSubsetOf<T>( ICollection<T> set, IEnumerable<T> other )
+		public static bool IsProperSubsetOf<T>(ICollection<T> set, IEnumerable<T> other)
 #else
-		public static bool IsProperSubsetOf<T>( ISet<T> set, IEnumerable<T> other )
+		public static bool IsProperSubsetOf<T>(ISet<T> set, IEnumerable<T> other)
 #endif
 		{
-#region CONTRACT
-			Contract.Assert( set != null, "set != null " );
+			Debug.Assert(set != null, "set != null ");
+			Ensure.NotNull(other);
 
-			if ( other == null )
+			if (other is ICollection<T> asCollection)
 			{
-				throw new ArgumentNullException( "other" );
-			}
-#endregion CONTRACT
-
-			var asCollection = other as ICollection<T>;
-			if ( asCollection != null )
-			{
-				if ( set.Count == 0 )
+				if (set.Count == 0)
 				{
 					return 0 < asCollection.Count;
 				}
 
-				if ( asCollection.Count <= set.Count )
+				if (asCollection.Count <= set.Count)
 				{
 					return false;
 				}
 			}
 
-			int otherCount;
-			if ( !IsSubsetOfCore( set, other, out otherCount ) )
+			if (!IsSubsetOfCore(set, other, out var otherCount))
 			{
 				return false;
 			}
@@ -79,42 +43,33 @@ public static bool IsProperSubsetOf<T>( ISet<T> set, IEnumerable<T> other )
 			return set.Count < otherCount;
 		}
 
-		[Pure]
 #if NET35
-		public static bool IsSubsetOf<T>( ICollection<T> set, IEnumerable<T> other )
+		public static bool IsSubsetOf<T>(ICollection<T> set, IEnumerable<T> other)
 #else
-		public static bool IsSubsetOf<T>( ISet<T> set, IEnumerable<T> other )
+		public static bool IsSubsetOf<T>(ISet<T> set, IEnumerable<T> other)
 #endif
 		{
-#region CONTRACT
-			Contract.Assert( set != null, "set != null" );
-
-			if ( other == null )
-			{
-				throw new ArgumentNullException( "other" );
-			}
-#endregion CONTRACT
+			Debug.Assert(set != null, "set != null");
+			Ensure.NotNull(other);
 
-			if ( set.Count == 0 )
+			if (set.Count == 0)
 			{
 				return true;
 			}
 
-			var asCollection = other as ICollection<T>;
-			if ( asCollection != null && asCollection.Count < set.Count )
+			if (other is ICollection<T> asCollection && asCollection.Count < set.Count)
 			{
 				return false;
 			}
 
 			int checkedCount;
-			return IsSubsetOfCore( set, other, out checkedCount );
+			return IsSubsetOfCore(set, other, out checkedCount);
 		}
 
-		[Pure]
 #if NET35
-		private static bool IsSubsetOfCore<T>( ICollection<T> set, IEnumerable<T> other, out int otherCount )
+		private static bool IsSubsetOfCore<T>(ICollection<T> set, IEnumerable<T> other, out int otherCount)
 #else
-		private static bool IsSubsetOfCore<T>( ISet<T> set, IEnumerable<T> other, out int otherCount )
+		private static bool IsSubsetOfCore<T>(ISet<T> set, IEnumerable<T> other, out int otherCount)
 #endif
 		{
 			otherCount = 0;
@@ -122,22 +77,17 @@ private static bool IsSubsetOfCore<T>( ISet<T> set, IEnumerable<T> other, out in
 			// Other must be set to handle duplicated items.
 			// e.x., [1,2,3] is proper subset of [1,2,3,4,1] but not [1,1,1,1,1]
 #if NET35
-			var asSet = other as HashSet<T>;
+			var asSet = other as HashSet<T> ?? new HashSet<T>(other);
 #else
-			var asSet = other as ISet<T>;
+			var asSet = other as ISet<T> ?? new HashSet<T>(other);
 #endif
-			if ( asSet == null )
-			{
-				asSet = new HashSet<T>( other );
-			}
-
 			int matchCount = 0;
 
-			foreach ( var item in asSet )
+			foreach (var item in asSet)
 			{
 				otherCount++;
 
-				if ( set.Contains( item ) )
+				if (set.Contains(item))
 				{
 					matchCount++;
 				}
@@ -147,33 +97,24 @@ private static bool IsSubsetOfCore<T>( ISet<T> set, IEnumerable<T> other, out in
 			return set.Count <= matchCount;
 		}
 
-		[Pure]
 #if NET35
-		public static bool IsProperSupersetOf<T>( ICollection<T> set, IEnumerable<T> other )
+		public static bool IsProperSupersetOf<T>(ICollection<T> set, IEnumerable<T> other)
 #else
-		public static bool IsProperSupersetOf<T>( ISet<T> set, IEnumerable<T> other )
+		public static bool IsProperSupersetOf<T>(ISet<T> set, IEnumerable<T> other)
 #endif
 		{
-#region CONTRACT
-			Contract.Assert( set != null, "set != null" );
-
-			if ( other == null )
-			{
-				throw new ArgumentNullException( "other" );
-			}
-#endregion CONTRACT
+			Debug.Assert(set != null, "set != null");
+			Ensure.NotNull(other);
 
-			var asCollection = other as ICollection<T>;
-			if ( asCollection != null )
+			if (other is ICollection<T> asCollection)
 			{
-				if ( asCollection.Count == 0 )
+				if (asCollection.Count == 0)
 				{
 					return 0 < set.Count;
 				}
 			}
 
-			int checkedCount;
-			if ( !IsSupersetOfCore( set, other, out checkedCount ) )
+			if (!IsSupersetOfCore(set, other, out var checkedCount))
 			{
 				return false;
 			}
@@ -181,45 +122,35 @@ public static bool IsProperSupersetOf<T>( ISet<T> set, IEnumerable<T> other )
 			return checkedCount < set.Count;
 		}
 
-		[Pure]
 #if NET35
-		public static bool IsSupersetOf<T>( ICollection<T> set, IEnumerable<T> other )
+		public static bool IsSupersetOf<T>(ICollection<T> set, IEnumerable<T> other)
 #else
-		public static bool IsSupersetOf<T>( ISet<T> set, IEnumerable<T> other )
+		public static bool IsSupersetOf<T>(ISet<T> set, IEnumerable<T> other)
 #endif
 		{
-#region CONTRACT
-			Contract.Assert( set != null, "set != null" );
+			Debug.Assert(set != null, "set != null");
+			Ensure.NotNull(other);
 
-			if ( other == null )
+			if (other is ICollection<T> asCollection && asCollection.Count < set.Count)
 			{
-				throw new ArgumentNullException( "other" );
-			}
-#endregion CONTRACT
-
-			var asCollection = other as ICollection<T>;
-			if ( asCollection != null && asCollection.Count < set.Count )
-			{
-				if ( asCollection.Count == 0 )
+				if (asCollection.Count == 0)
 				{
 					return true;
 				}
 
-				if ( set.Count <= asCollection.Count )
+				if (set.Count <= asCollection.Count)
 				{
 					return false;
 				}
 			}
 
-			int checkedCount;
-			return IsSupersetOfCore( set, other, out checkedCount );
+			return IsSupersetOfCore(set, other, out _);
 		}
 
-		[Pure]
 #if NET35
-		private static bool IsSupersetOfCore<T>( ICollection<T> set, IEnumerable<T> other, out int otherCount )
+		private static bool IsSupersetOfCore<T>(ICollection<T> set, IEnumerable<T> other, out int otherCount)
 #else
-		private static bool IsSupersetOfCore<T>( ISet<T> set, IEnumerable<T> other, out int otherCount )
+		private static bool IsSupersetOfCore<T>(ISet<T> set, IEnumerable<T> other, out int otherCount)
 #endif
 		{
 			otherCount = 0;
@@ -227,20 +158,16 @@ private static bool IsSupersetOfCore<T>( ISet<T> set, IEnumerable<T> other, out
 			// Other must be set to handle duplicated items.
 			// e.x., [1,2,3] is proper superset of [1,2] and [1,2,1]
 #if NET35
-			var asSet = other as HashSet<T>;
+			var asSet = other as HashSet<T> ?? new HashSet<T>(other);
 #else
-			var asSet = other as ISet<T>;
+			var asSet = other as ISet<T> ?? new HashSet<T>(other);
 #endif
-			if ( asSet == null )
-			{
-				asSet = new HashSet<T>( other );
-			}
 
-			foreach ( var item in asSet )
+			foreach (var item in asSet)
 			{
 				otherCount++;
 
-				if ( !set.Contains( item ) )
+				if (!set.Contains(item))
 				{
 					return false;
 				}
@@ -250,50 +177,35 @@ private static bool IsSupersetOfCore<T>( ISet<T> set, IEnumerable<T> other, out
 			return true;
 		}
 
-		[Pure]
 #if NET35
-		public static bool Overlaps<T>( ICollection<T> set, IEnumerable<T> other )
+		public static bool Overlaps<T>(ICollection<T> set, IEnumerable<T> other)
 #else
-		public static bool Overlaps<T>( ISet<T> set, IEnumerable<T> other )
+		public static bool Overlaps<T>(ISet<T> set, IEnumerable<T> other)
 #endif
 		{
-#region CONTRACT
-			Contract.Assert( set != null, "set != null" );
-
-			if ( other == null )
-			{
-				throw new ArgumentNullException( "other" );
-			}
-#endregion CONTRACT
+			Debug.Assert(set != null, "set != null");
+			Ensure.NotNull(other);
 
-			if ( set.Count == 0 )
+			if (set.Count == 0)
 			{
 				return false;
 			}
 
-			return other.Any( item => set.Contains( item ) );
+			return other.Any(item => set.Contains(item));
 		}
 
-		[Pure]
 #if NET35
-		public static bool SetEquals<T>( ICollection<T> set, IEnumerable<T> other )
+		public static bool SetEquals<T>(ICollection<T> set, IEnumerable<T> other)
 #else
-		public static bool SetEquals<T>( ISet<T> set, IEnumerable<T> other )
+		public static bool SetEquals<T>(ISet<T> set, IEnumerable<T> other)
 #endif
 		{
-#region CONTRACT
-			Contract.Assert( set != null, "set != null" );
-
-			if ( other == null )
-			{
-				throw new ArgumentNullException( "other" );
-			}
-#endregion CONTRACT
+			Debug.Assert(set != null, "set != null");
+			Ensure.NotNull(other);
 
-			if ( set.Count == 0 )
+			if (set.Count == 0)
 			{
-				var asCollection = other as ICollection<T>;
-				if ( asCollection != null )
+				if (other is ICollection<T> asCollection)
 				{
 					return asCollection.Count == 0;
 				}
@@ -301,14 +213,14 @@ public static bool SetEquals<T>( ISet<T> set, IEnumerable<T> other )
 
 			// Cannot use other.All() here because it always returns true for empty source.
 #if NET35
-			var asSet = other as HashSet<T> ?? new HashSet<T>( other );
+			var asSet = other as HashSet<T> ?? new HashSet<T>(other);
 #else
-			var asSet = other as ISet<T> ?? new HashSet<T>( other );
+			var asSet = other as ISet<T> ?? new HashSet<T>(other);
 #endif
 			int matchCount = 0;
-			foreach ( var item in asSet )
+			foreach (var item in asSet)
 			{
-				if ( !set.Contains( item ) )
+				if (!set.Contains(item))
 				{
 					return false;
 				}
@@ -322,4 +234,3 @@ public static bool SetEquals<T>( ISet<T> set, IEnumerable<T> other )
 		}
 	}
 }
-#endif // !UNITY
diff --git a/src/MsgPack/Timestamp.Conversion.cs b/src/MsgPack/Timestamp.Conversion.cs
index 56b28063c..fa6db97ec 100644
--- a/src/MsgPack/Timestamp.Conversion.cs
+++ b/src/MsgPack/Timestamp.Conversion.cs
@@ -19,25 +19,29 @@
 #endregion -- License Terms --
 
 using System;
+using System.Buffers;
+using System.Buffers.Binary;
 using System.Globalization;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
 
 namespace MsgPack
 {
 	partial struct Timestamp
 	{
-		private long ToTicks( Type destination )
+		private long ToTicks(Type destination)
 		{
-			if ( this.unixEpochSeconds < MinUnixEpochSecondsForTicks )
+			if (this.unixEpochSeconds < MinUnixEpochSecondsForTicks)
 			{
-				throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "This value is too small for '{0}'.", destination ) );
+				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "This value is too small for '{0}'.", destination));
 			}
 
-			if ( this.unixEpochSeconds > MaxUnixEpochSecondsForTicks )
+			if (this.unixEpochSeconds > MaxUnixEpochSecondsForTicks)
 			{
-				throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "This value is too large for '{0}'.", destination ) );
+				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "This value is too large for '{0}'.", destination));
 			}
 
-			return ( UnixEpochInSeconds + this.unixEpochSeconds ) * SecondsToTicks + this.nanoseconds / NanoToTicks;
+			return (UnixEpochInSeconds + this.unixEpochSeconds) * SecondsToTicks + this.nanoseconds / NanoToTicks;
 		}
 
 		/// <summary>
@@ -49,7 +53,7 @@ private long ToTicks( Type destination )
 		/// </exception>
 		public DateTime ToDateTime()
 		{
-			return new DateTime( this.ToTicks( typeof( DateTime ) ), DateTimeKind.Utc );
+			return new DateTime(this.ToTicks(typeof(DateTime)), DateTimeKind.Utc);
 		}
 
 		/// <summary>
@@ -61,7 +65,7 @@ public DateTime ToDateTime()
 		/// </exception>
 		public DateTimeOffset ToDateTimeOffset()
 		{
-			return new DateTimeOffset( this.ToTicks( typeof( DateTimeOffset ) ), TimeSpan.Zero );
+			return new DateTimeOffset(this.ToTicks(typeof(DateTimeOffset)), TimeSpan.Zero);
 		}
 
 		/// <summary>
@@ -123,23 +127,23 @@ public MessagePackExtendedTypeObject Encode()
 			}
 		}
 
-		private static void FromDateTimeTicks( long ticks, out long unixEpocSeconds, out int nanoSeconds )
+		private static void FromDateTimeTicks(long ticks, out long unixEpocSeconds, out int nanoSeconds)
 		{
-			FromOffsetTicks( ticks - UnixEpochTicks, out unixEpocSeconds, out nanoSeconds );
+			FromOffsetTicks(ticks - UnixEpochTicks, out unixEpocSeconds, out nanoSeconds);
 		}
 
-		private static void FromOffsetTicks( long ticks, out long unixEpocSeconds, out int nanoSeconds )
+		private static void FromOffsetTicks(long ticks, out long unixEpocSeconds, out int nanoSeconds)
 		{
 			long remaining;
-			unixEpocSeconds = DivRem( ticks, SecondsToTicks, out remaining );
-			nanoSeconds = unchecked( ( int )remaining ) * 100;
-			if ( nanoSeconds < 0 )
+			unixEpocSeconds = DivRem(ticks, SecondsToTicks, out remaining);
+			nanoSeconds = unchecked((int)remaining) * 100;
+			if (nanoSeconds < 0)
 			{
 				// In this case, we must adjust these values
 				// from "negative nanosec from nearest larger negative integer"
 				// to "positive nanosec from nearest smaller nagative integer".
 				unixEpocSeconds -= 1;
-				nanoSeconds = ( MaxNanoSeconds + 1 ) + nanoSeconds;
+				nanoSeconds = (MaxNanoSeconds + 1) + nanoSeconds;
 			}
 		}
 
@@ -148,12 +152,12 @@ private static void FromOffsetTicks( long ticks, out long unixEpocSeconds, out i
 		/// </summary>
 		/// <param name="value">A <see cref="DateTime"/>.</param>
 		/// <returns>An equivalant <see cref="Timestamp"/> to specified <see cref="DateTime"/></returns>
-		public static Timestamp FromDateTime( DateTime value )
+		public static Timestamp FromDateTime(DateTime value)
 		{
 			long unixEpocSeconds;
 			int nanoSeconds;
-			FromDateTimeTicks( ( value.Kind == DateTimeKind.Local ? value.ToUniversalTime() : value ).Ticks, out unixEpocSeconds, out nanoSeconds );
-			return new Timestamp( unixEpocSeconds, nanoSeconds );
+			FromDateTimeTicks((value.Kind == DateTimeKind.Local ? value.ToUniversalTime() : value).Ticks, out unixEpocSeconds, out nanoSeconds);
+			return new Timestamp(unixEpocSeconds, nanoSeconds);
 		}
 
 		/// <summary>
@@ -161,12 +165,12 @@ public static Timestamp FromDateTime( DateTime value )
 		/// </summary>
 		/// <param name="value">A <see cref="DateTimeOffset"/>.</param>
 		/// <returns>An equivalant <see cref="Timestamp"/> to specified <see cref="DateTimeOffset"/></returns>
-		public static Timestamp FromDateTimeOffset( DateTimeOffset value )
+		public static Timestamp FromDateTimeOffset(DateTimeOffset value)
 		{
 			long unixEpocSeconds;
 			int nanoSeconds;
-			FromDateTimeTicks( value.UtcTicks, out unixEpocSeconds, out nanoSeconds );
-			return new Timestamp( unixEpocSeconds, nanoSeconds );
+			FromDateTimeTicks(value.UtcTicks, out unixEpocSeconds, out nanoSeconds);
+			return new Timestamp(unixEpocSeconds, nanoSeconds);
 		}
 
 		/// <summary>
@@ -229,7 +233,7 @@ public static Timestamp Decode( MessagePackExtendedTypeObject value )
 		/// <exception cref="InvalidOperationException">
 		///		This instance represents before <see cref="DateTime.MinValue"/> or after <see cref="DateTime.MaxValue"/>.
 		/// </exception>
-		public static explicit operator DateTime( Timestamp value )
+		public static explicit operator DateTime(Timestamp value)
 		{
 			return value.ToDateTime();
 		}
@@ -242,7 +246,7 @@ public static explicit operator DateTime( Timestamp value )
 		/// <exception cref="InvalidOperationException">
 		///		This instance represents before <see cref="DateTimeOffset.MinValue"/> or after <see cref="DateTimeOffset.MaxValue"/>.
 		/// </exception>
-		public static explicit operator DateTimeOffset( Timestamp value )
+		public static explicit operator DateTimeOffset(Timestamp value)
 		{
 			return value.ToDateTimeOffset();
 		}
@@ -252,7 +256,7 @@ public static explicit operator DateTimeOffset( Timestamp value )
 		/// </summary>
 		/// <param name="value">A <see cref="Timestamp"/>.</param>
 		/// <returns>A <see cref="MessagePackExtendedTypeObject"/>.</returns>
-		public static implicit operator MessagePackExtendedTypeObject( Timestamp value )
+		public static implicit operator MessagePackExtendedTypeObject(Timestamp value)
 		{
 			return value.Encode();
 		}
@@ -262,9 +266,9 @@ public static implicit operator MessagePackExtendedTypeObject( Timestamp value )
 		/// </summary>
 		/// <param name="value">A <see cref="DateTime"/>.</param>
 		/// <returns>A <see cref="Timestamp"/>.</returns>
-		public static implicit operator Timestamp( DateTime value )
+		public static implicit operator Timestamp(DateTime value)
 		{
-			return FromDateTime( value );
+			return FromDateTime(value);
 		}
 
 		/// <summary>
@@ -272,9 +276,9 @@ public static implicit operator Timestamp( DateTime value )
 		/// </summary>
 		/// <param name="value">A <see cref="DateTimeOffset"/>.</param>
 		/// <returns>A <see cref="Timestamp"/>.</returns>
-		public static implicit operator Timestamp( DateTimeOffset value )
+		public static implicit operator Timestamp(DateTimeOffset value)
 		{
-			return FromDateTimeOffset( value );
+			return FromDateTimeOffset(value);
 		}
 
 		/// <summary>
@@ -289,9 +293,9 @@ public static implicit operator Timestamp( DateTimeOffset value )
 		/// <exception cref="ArgumentOutOfRangeException">
 		///		<paramref name="value"/> have invalid nanoseconds value.
 		/// </exception>
-		public static explicit operator Timestamp( MessagePackExtendedTypeObject value )
+		public static explicit operator Timestamp(MessagePackExtendedTypeObject value)
 		{
-			return Decode( value );
+			return Decode(value);
 		}
 	}
 }
diff --git a/src/MsgPack/Timestamp.ParseExact.cs b/src/MsgPack/Timestamp.ParseExact.cs
index 36347ce13..5f9bad8f0 100644
--- a/src/MsgPack/Timestamp.ParseExact.cs
+++ b/src/MsgPack/Timestamp.ParseExact.cs
@@ -1,38 +1,14 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 using System.Globalization;
 
 namespace MsgPack
 {
-	partial struct Timestamp
+	public partial struct Timestamp
 	{
 		/// <summary>
 		///		Converts specified <see cref="String"/> representation of a msgpack timestamp to its <see cref="Timestamp"/> equivalant
@@ -64,9 +40,9 @@ partial struct Timestamp
 		/// <exception cref="FormatException">
 		///		The specified <paramref name="input"/> is not valid for the specified <paramref name="format"/> and <paramref name="formatProvider"/>.
 		/// </exception>
-		public static Timestamp ParseExact( string input, string format, IFormatProvider formatProvider )
+		public static Timestamp ParseExact(string input, string format, IFormatProvider formatProvider)
 		{
-			return ParseExact( input, format, formatProvider, DateTimeStyles.None );
+			return ParseExact(input, format, formatProvider, DateTimeStyles.None);
 		}
 
 		/// <summary>
@@ -104,10 +80,10 @@ public static Timestamp ParseExact( string input, string format, IFormatProvider
 		/// <exception cref="FormatException">
 		///		The specified <paramref name="input"/> is not valid for the specified <paramref name="format"/>, <paramref name="formatProvider"/>, and <paramref name="styles"/>.
 		/// </exception>
-		public static Timestamp ParseExact( string input, string format, IFormatProvider formatProvider, DateTimeStyles styles )
+		public static Timestamp ParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles)
 		{
 			Timestamp result;
-			HandleParseResult( TryParseExactCore( input, format, formatProvider, styles, out result ), "Cannot parse specified input with specified format." );
+			HandleParseResult(TryParseExactCore(input, format, formatProvider, styles, out result), "Cannot parse specified input with specified format.");
 			return result;
 		}
 
@@ -146,25 +122,25 @@ public static Timestamp ParseExact( string input, string format, IFormatProvider
 		/// <exception cref="FormatException">
 		///		The specified <paramref name="input"/> is not valid for any specified <paramref name="formats"/>, <paramref name="formatProvider"/>, and <paramref name="styles"/>.
 		/// </exception>
-		public static Timestamp ParseExact( string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles )
+		public static Timestamp ParseExact(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles)
 		{
 			Timestamp result;
-			HandleParseResult( TryParseExactCore( input, formats, formatProvider, styles, out result ), "Cannot parse specified input with any specified formats." );
+			HandleParseResult(TryParseExactCore(input, formats, formatProvider, styles, out result), "Cannot parse specified input with any specified formats.");
 			return result;
 		}
 
-		private static void HandleParseResult( TimestampParseResult result, string messageForInvalidInput )
+		private static void HandleParseResult(TimestampParseResult result, string messageForInvalidInput)
 		{
-			if ( result == TimestampParseResult.Success )
+			if (result == TimestampParseResult.Success)
 			{
 				return;
 			}
 
 			string parameterName;
-			string message;
+			string? message;
 
 			var parameter = result & TimestampParseResult.ParameterMask;
-			switch( parameter )
+			switch (parameter)
 			{
 				case TimestampParseResult.ParameterFormat:
 				{
@@ -173,7 +149,7 @@ private static void HandleParseResult( TimestampParseResult result, string messa
 				}
 				default:
 				{
-					Contract.Assert( parameter == TimestampParseResult.ParameterInput, parameter + " == TimestampParseResult.Input" );
+					Debug.Assert(parameter == TimestampParseResult.ParameterInput, parameter + " == TimestampParseResult.Input");
 					parameterName = "input";
 					break;
 				}
@@ -181,11 +157,11 @@ private static void HandleParseResult( TimestampParseResult result, string messa
 
 			var kind = result & TimestampParseResult.KindMask;
 
-			switch ( kind )
+			switch (kind)
 			{
 				case TimestampParseResult.KindEmpty:
 				{
-					message = String.Format( CultureInfo.CurrentCulture, "'{0}' must not be empty.", parameterName );
+					message = String.Format(CultureInfo.CurrentCulture, "'{0}' must not be empty.", parameterName);
 					break;
 				}
 				case TimestampParseResult.KindExtraCharactors:
@@ -270,9 +246,9 @@ private static void HandleParseResult( TimestampParseResult result, string messa
 				}
 				case TimestampParseResult.KindNull:
 				{
-					Contract.Assert(
-						( result & TimestampParseResult.ExceptionTypeMask ) == TimestampParseResult.ArgumentNullException,
-						( result & TimestampParseResult.ExceptionTypeMask ) + " == TimestampParseResult.ArgumentNullException"
+					Debug.Assert(
+						(result & TimestampParseResult.ExceptionTypeMask) == TimestampParseResult.ArgumentNullException,
+						(result & TimestampParseResult.ExceptionTypeMask) + " == TimestampParseResult.ArgumentNullException"
 					);
 					message = null;
 					break;
@@ -294,29 +270,29 @@ private static void HandleParseResult( TimestampParseResult result, string messa
 				}
 				default:
 				{
-					Contract.Assert( kind == TimestampParseResult.KindNoMatchedFormats, kind + " == TimestampParseResult.KindNoMatchedFormats" );
+					Debug.Assert(kind == TimestampParseResult.KindNoMatchedFormats, kind + " == TimestampParseResult.KindNoMatchedFormats");
 					message = "The input is not valid Timestamp.";
 					break;
 				}
 			}
 
-			switch( result & TimestampParseResult.ExceptionTypeMask )
+			switch (result & TimestampParseResult.ExceptionTypeMask)
 			{
 				case TimestampParseResult.ArgumentNullException:
 				{
-					throw new ArgumentNullException( parameterName );
+					throw new ArgumentNullException(parameterName);
 				}
 				case TimestampParseResult.ArgumentException:
 				{
-					throw new ArgumentException( message, parameterName );
+					throw new ArgumentException(message, parameterName);
 				}
 				default:
 				{
-					Contract.Assert(
-						( result & TimestampParseResult.ExceptionTypeMask ) == TimestampParseResult.FormatException,
-						( result & TimestampParseResult.ExceptionTypeMask ) + " == TimestampParseResult.FormatException"
+					Debug.Assert(
+						(result & TimestampParseResult.ExceptionTypeMask) == TimestampParseResult.FormatException,
+						(result & TimestampParseResult.ExceptionTypeMask) + " == TimestampParseResult.FormatException"
 					);
-					throw new FormatException( message );
+					throw new FormatException(message);
 				}
 			}
 		}
diff --git a/src/MsgPack/Timestamp.Properties.cs b/src/MsgPack/Timestamp.Properties.cs
index a42f82453..7c75698c4 100644
--- a/src/MsgPack/Timestamp.Properties.cs
+++ b/src/MsgPack/Timestamp.Properties.cs
@@ -1,37 +1,13 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
+using System.Diagnostics;
 
 namespace MsgPack
 {
-	partial struct Timestamp
+	public partial struct Timestamp
 	{
 		private const int SecondsPerMinutes = 60;
 		private const int SecondsPerHours = SecondsPerMinutes * 60;
@@ -70,7 +46,7 @@ public long UnixEpochSecondsPart
 		/// </remarks>
 		public int NanosecondsPart
 		{
-			get { return unchecked( ( int )this.nanoseconds ); }
+			get { return unchecked((int)this.nanoseconds); }
 		}
 
 		/// <summary>
@@ -83,7 +59,7 @@ public long Year
 			{
 				long year;
 				int month, day, dayOfYear;
-				this.GetDatePart( out year, out month, out day, out dayOfYear );
+				this.GetDatePart(out year, out month, out day, out dayOfYear);
 				return year;
 			}
 		}
@@ -98,7 +74,7 @@ public int Month
 			{
 				long year;
 				int month, day, dayOfYear;
-				this.GetDatePart( out year, out month, out day, out dayOfYear );
+				this.GetDatePart(out year, out month, out day, out dayOfYear);
 				return month;
 			}
 		}
@@ -113,7 +89,7 @@ public int Day
 			{
 				long year;
 				int month, day, dayOfYear;
-				this.GetDatePart( out year, out month, out day, out dayOfYear );
+				this.GetDatePart(out year, out month, out day, out dayOfYear);
 				return day;
 			}
 		}
@@ -127,12 +103,12 @@ public int Hour
 			get
 			{
 				long remainder;
-				var hour = DivRem( this.unixEpochSeconds, SecondsPerHours, out remainder ) % 24;
+				var hour = DivRem(this.unixEpochSeconds, SecondsPerHours, out remainder) % 24;
 				unchecked
 				{
 					return
-						( int )( this.unixEpochSeconds < 0
-							? hour + ( remainder != 0 ? 23 : ( hour < 0 ? 24 : 0 ) )
+						(int)(this.unixEpochSeconds < 0
+							? hour + (remainder != 0 ? 23 : (hour < 0 ? 24 : 0))
 							: hour
 						);
 				}
@@ -148,12 +124,12 @@ public int Minute
 			get
 			{
 				long remainder;
-				var minute = DivRem( this.unixEpochSeconds, SecondsPerMinutes, out remainder ) % 60;
+				var minute = DivRem(this.unixEpochSeconds, SecondsPerMinutes, out remainder) % 60;
 				unchecked
 				{
 					return
-						( int )( this.unixEpochSeconds < 0
-							? minute + ( remainder != 0 ? 59 : ( minute < 0 ? 60 : 0 ) )
+						(int)(this.unixEpochSeconds < 0
+							? minute + (remainder != 0 ? 59 : (minute < 0 ? 60 : 0))
 							: minute
 						);
 				}
@@ -168,7 +144,7 @@ public int Second
 		{
 			get
 			{
-				var second = unchecked( ( int )( this.unixEpochSeconds % 60 ) );
+				var second = unchecked((int)(this.unixEpochSeconds % 60));
 				return second < 0 ? second + 60 : second;
 			}
 		}
@@ -179,7 +155,7 @@ public int Second
 		/// <value>A millisecond portion of this instance. The value will be between 0 and 999.</value>
 		public int Millisecond
 		{
-			get { return this.NanosecondsPart / ( 1000 * 1000 ); }
+			get { return this.NanosecondsPart / (1000 * 1000); }
 		}
 
 		/// <summary>
@@ -188,7 +164,7 @@ public int Millisecond
 		/// <value>A microsecond portion of this instance. The value will be between 0 and 999.</value>
 		public int Microsecond
 		{
-			get { return ( this.NanosecondsPart / 1000 ) % 1000; }
+			get { return (this.NanosecondsPart / 1000) % 1000; }
 		}
 
 		/// <summary>
@@ -200,7 +176,7 @@ public int Microsecond
 		/// </remarks>
 		public int Nanosecond
 		{
-			get { return ( this.NanosecondsPart ) % 1000; }
+			get { return (this.NanosecondsPart) % 1000; }
 		}
 
 		/// <summary>
@@ -211,7 +187,7 @@ public Timestamp Date
 		{
 			get
 			{
-				return new Timestamp( this.unixEpochSeconds - this.TimeOfDay.unixEpochSeconds, 0 );
+				return new Timestamp(this.unixEpochSeconds - this.TimeOfDay.unixEpochSeconds, 0);
 			}
 		}
 
@@ -225,7 +201,7 @@ public Timestamp TimeOfDay
 			{
 				return
 					new Timestamp(
-						this.unixEpochSeconds < 0 ? ( this.unixEpochSeconds % SecondsPerDay + SecondsPerDay ) : ( this.unixEpochSeconds % SecondsPerDay ),
+						this.unixEpochSeconds < 0 ? (this.unixEpochSeconds % SecondsPerDay + SecondsPerDay) : (this.unixEpochSeconds % SecondsPerDay),
 						this.NanosecondsPart
 					);
 			}
@@ -240,12 +216,12 @@ public DayOfWeek DayOfWeek
 			get
 			{
 				long remainder;
-				var divided = unchecked( ( int )DivRem( this.unixEpochSeconds, SecondsPerDay, out remainder ));
-				return	
-					( DayOfWeek )(
+				var divided = unchecked((int)DivRem(this.unixEpochSeconds, SecondsPerDay, out remainder));
+				return
+					(DayOfWeek)(
 						(
-							( this.unixEpochSeconds < 0
-								? ( ( divided + ( ( int )remainder < 0 ? -1 : 0 ) ) % 7 + 7 )
+							(this.unixEpochSeconds < 0
+								? ((divided + ((int)remainder < 0 ? -1 : 0)) % 7 + 7)
 								: divided
 							) + DayOfWeekOfEpoc
 						) % 7
@@ -263,7 +239,7 @@ public int DayOfYear
 			{
 				long year;
 				int month, day, dayOfYear;
-				this.GetDatePart( out year, out month, out day, out dayOfYear );
+				this.GetDatePart(out year, out month, out day, out dayOfYear);
 				return dayOfYear;
 			}
 		}
@@ -281,20 +257,20 @@ public int DayOfYear
 		/// </remarks>
 		public bool IsLeapYear
 		{
-			get { return IsLeapYearInternal( this.Year ); }
+			get { return IsLeapYearInternal(this.Year); }
 		}
 
-		internal static bool IsLeapYearInternal( long year )
+		internal static bool IsLeapYearInternal(long year)
 		{
 			// Note: This algorithm assumes that BC uses leap year same as AD and B.C.1 is 0.
 			// This algorithm avoids remainder operation as possible.
-			return !( year % 4 != 0 || ( year % 100 == 0 && year % 400 != 0 ) );
+			return !(year % 4 != 0 || (year % 100 == 0 && year % 400 != 0));
 		}
 
-		internal static int GetLastDay( int month, bool isLeapYear )
+		internal static int GetLastDay(int month, bool isLeapYear)
 		{
-			var lastDay = LastDays[ month ];
-			if ( month == 2 )
+			var lastDay = LastDays[month];
+			if (month == 2)
 			{
 				lastDay = isLeapYear ? 29 : 28;
 			}
@@ -302,27 +278,27 @@ internal static int GetLastDay( int month, bool isLeapYear )
 			return lastDay;
 		}
 
-		private void GetDatePart( out long year, out int month, out int day, out int dayOfYear )
+		private void GetDatePart(out long year, out int month, out int day, out int dayOfYear)
 		{
-			if ( this.unixEpochSeconds < -UnixEpochInSeconds )
+			if (this.unixEpochSeconds < -UnixEpochInSeconds)
 			{
-				this.GetDatePartBC( out year, out month, out day, out dayOfYear );
+				this.GetDatePartBC(out year, out month, out day, out dayOfYear);
 			}
 			else
 			{
-				this.GetDatePartAD( out year, out month, out day, out dayOfYear );
+				this.GetDatePartAD(out year, out month, out day, out dayOfYear);
 			}
 		}
 
-		private void GetDatePartAD( out long year, out int month, out int day, out int dayOfYear )
+		private void GetDatePartAD(out long year, out int month, out int day, out int dayOfYear)
 		{
-			Contract.Assert( this.unixEpochSeconds >= -UnixEpochInSeconds, this.unixEpochSeconds + " > " + ( -UnixEpochInSeconds ) );
+			Debug.Assert(this.unixEpochSeconds >= -UnixEpochInSeconds, this.unixEpochSeconds + " > " + (-UnixEpochInSeconds));
 
 			// From coreclr System.DateTime.cs
 			// https://github.com/dotnet/coreclr/blob/0825741447c14a6a70c60b7c429e16f95214e74e/src/mscorlib/shared/System/DateTime.cs#L863
 
 			// First, use 0001-01-01 as epoch to simplify leap year calculation
-			var seconds = unchecked( ( ulong )( this.unixEpochSeconds + UnixEpochInSeconds ) );
+			var seconds = unchecked((ulong)(this.unixEpochSeconds + UnixEpochInSeconds));
 
 			// number of days since 0001-01-01
 			var daysOffset = seconds / SecondsPerDay;
@@ -330,12 +306,12 @@ private void GetDatePartAD( out long year, out int month, out int day, out int d
 			// number of whole 400-year periods since 0001-01-01
 			var numberOf400Years = daysOffset / DaysPer400Years;
 			// day number within 400-year period
-			var daysIn400Years = unchecked( ( uint )( daysOffset - numberOf400Years * DaysPer400Years ) );
+			var daysIn400Years = unchecked((uint)(daysOffset - numberOf400Years * DaysPer400Years));
 
 			// number of whole 100-year periods within 400-year period
 			var numberOf100Years = daysIn400Years / DaysPer100Years;
 			// Last 100-year period has an extra day, so decrement result if 4
-			if ( numberOf100Years == 4 )
+			if (numberOf100Years == 4)
 			{
 				numberOf100Years = 3;
 			}
@@ -351,63 +327,62 @@ private void GetDatePartAD( out long year, out int month, out int day, out int d
 			// number of whole years within 4-year period
 			var numberOf1Year = daysIn4Years / DaysPerYear;
 			// Last year has an extra day, so decrement result if 4
-			if ( numberOf1Year == 4 )
+			if (numberOf1Year == 4)
 			{
 				numberOf1Year = 3;
 			}
 
 			// compute year
-			year = unchecked( ( long )( numberOf400Years * 400 + numberOf100Years * 100 + numberOf4years * 4 + numberOf1Year + 1 ) );
+			year = unchecked((long)(numberOf400Years * 400 + numberOf100Years * 100 + numberOf4years * 4 + numberOf1Year + 1));
 			// day number within year
 			var daysInYear = daysIn4Years - numberOf1Year * DaysPerYear;
-			dayOfYear = unchecked( ( int )( daysInYear + 1 ) );
+			dayOfYear = unchecked((int)(daysInYear + 1));
 			// Leap year calculation
-			var isLeapYear = numberOf1Year == 3 && ( numberOf4years != 24 || numberOf100Years == 3 );
+			var isLeapYear = numberOf1Year == 3 && (numberOf4years != 24 || numberOf100Years == 3);
 			var days = isLeapYear ? DaysToMonth366 : DaysToMonth365;
 			// All months have less than 32 days, so n >> 5 is a good conservative
 			// estimate for the month
-			var numberOfMonth = ( daysInYear >> 5 ) + 1;
-#if DEBUG
-			Contract.Assert( numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear );
-#endif // DEBUG
+			var numberOfMonth = (daysInYear >> 5) + 1;
+
+			Debug.Assert(numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear);
+
 			// m = 1-based month number
-			while ( daysInYear >= days[ numberOfMonth ] )
+			while (daysInYear >= days[numberOfMonth])
 			{
 				numberOfMonth++;
-#if DEBUG
-				Contract.Assert( numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear );
-#endif // DEBUG
+
+				Debug.Assert(numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear);
 			}
 			// compute month and day
-			month = unchecked( ( int )numberOfMonth );
-			day = unchecked( ( int )( daysInYear - days[ numberOfMonth - 1 ] + 1 ) );
+			month = unchecked((int)numberOfMonth);
+			day = unchecked((int)(daysInYear - days[numberOfMonth - 1] + 1));
 		}
 
-		private void GetDatePartBC( out long year, out int month, out int day, out int dayOfYear )
+		private void GetDatePartBC(out long year, out int month, out int day, out int dayOfYear)
 		{
-			Contract.Assert( this.unixEpochSeconds < -UnixEpochInSeconds, this.unixEpochSeconds + " > " + ( -UnixEpochInSeconds ) );
+			Debug.Assert(this.unixEpochSeconds < -UnixEpochInSeconds, this.unixEpochSeconds + " > " + (-UnixEpochInSeconds));
 
 			// From coreclr System.DateTime.cs
 			// https://github.com/dotnet/coreclr/blob/0825741447c14a6a70c60b7c429e16f95214e74e/src/mscorlib/shared/System/DateTime.cs#L863
 
 			// First, use 0001-01-01 as epoch to simplify leap year calculation.
 			// This method calculate negative offset from 0001-01-01.
-			var seconds = unchecked( ( ulong )( ( this.unixEpochSeconds + UnixEpochInSeconds ) * -1 ) );
+			var seconds = unchecked((ulong)((this.unixEpochSeconds + UnixEpochInSeconds) * -1));
 
 			// number of days since 0001-01-01
 			var daysOffset = seconds / SecondsPerDay;
-			daysOffset += ( seconds % SecondsPerDay ) > 0 ? 1u : 0u;
+			daysOffset += (seconds % SecondsPerDay) > 0 ? 1u : 0u;
 
 			// number of whole 400-year periods since 0001-01-01
-			var numberOf400Years = ( daysOffset - 1 ) / DaysPer400Years; // decrement offset 1 to adjust 1 to 12-31
-			// day number within 400-year period
-			var daysIn400Years = unchecked( ( uint )( daysOffset - numberOf400Years * DaysPer400Years ) );
+			var numberOf400Years = (daysOffset - 1) / DaysPer400Years; // decrement offset 1 to adjust 1 to 12-31
+																	   // day number within 400-year period
+			var daysIn400Years = unchecked((uint)(daysOffset - numberOf400Years * DaysPer400Years));
 
 			// number of whole 100-year periods within 400-year period
 			var numberOf100Years =
-				daysIn400Years <= ( DaysPer100Years  + 1 ) // 1st year is leap year (power of 400)
+				daysIn400Years <= (DaysPer100Years + 1) // 1st year is leap year (power of 400)
 					? 0
-					: ( ( daysIn400Years - 2 ) / DaysPer100Years ); // decrement 1st leap year day and offset 1 to adjust 1 to 12-31
+					: ((daysIn400Years - 2) / DaysPer100Years); // decrement 1st leap year day and offset 1 to adjust 1 to 12-31
 
 			// day number within 100-year period
 			var daysIn100Years = daysIn400Years - numberOf100Years * DaysPer100Years;
@@ -416,46 +391,45 @@ private void GetDatePartBC( out long year, out int month, out int day, out int d
 			var numberOf4years =
 				daysIn100Years == 0
 					? 0
-					: ( ( daysIn100Years - 1 ) / DaysPer4Years ); // decrement offset 1 to adjust 1 to 12-31
+					: ((daysIn100Years - 1) / DaysPer4Years); // decrement offset 1 to adjust 1 to 12-31
 
 			// day number within 4-year period
 			var daysIn4Years = daysIn100Years - numberOf4years * DaysPer4Years;
 
 			// number of whole years within 4-year period
 			var numberOf1Year =
-				daysIn4Years <= ( DaysPerYear + ( numberOf4years != 0 ? 1 : 0 ) ) // is leap year in 4 years range?
+				daysIn4Years <= (DaysPerYear + (numberOf4years != 0 ? 1 : 0)) // is leap year in 4 years range?
 					? 0
-					: ( ( daysIn4Years - 2 ) / DaysPerYear ); // decrement 1st leap year day and offset 1 to adjust 1 to 12-31
+					: ((daysIn4Years - 2) / DaysPerYear); // decrement 1st leap year day and offset 1 to adjust 1 to 12-31
 
 			// compute year, note that 0001 -1 is 0000 (=B.C.1)
-			year = -unchecked( ( long )( numberOf400Years * 400 + numberOf100Years * 100 + numberOf4years * 4 + numberOf1Year ) );
-			var isLeapYear = numberOf1Year == 0 && ( numberOf4years != 0 || numberOf100Years == 0 );
+			year = -unchecked((long)(numberOf400Years * 400 + numberOf100Years * 100 + numberOf4years * 4 + numberOf1Year));
+			var isLeapYear = numberOf1Year == 0 && (numberOf4years != 0 || numberOf100Years == 0);
 			// day number within year
 			var daysInYear =
 				isLeapYear
-				? ( 366 - daysIn4Years )
-				: ( 365 - ( daysIn4Years - 1 - numberOf1Year * DaysPerYear ) );
+				? (366 - daysIn4Years)
+				: (365 - (daysIn4Years - 1 - numberOf1Year * DaysPerYear));
 
-			dayOfYear = unchecked( ( int )( daysInYear + 1 ) );
+			dayOfYear = unchecked((int)(daysInYear + 1));
 			// Leap year calculation
 			var days = isLeapYear ? DaysToMonth366 : DaysToMonth365;
 			// All months have more than 32 days, so n >> 5 is a good conservative
 			// estimate for the month
-			var numberOfMonth = ( daysInYear >> 5 ) + 1;
-#if DEBUG
-			Contract.Assert( numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear );
-#endif // DEBUG
+			var numberOfMonth = (daysInYear >> 5) + 1;
+
+			Debug.Assert(numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear);
+
 			// m = 1-based month number
-			while ( daysInYear >= days[ numberOfMonth ] )
+			while (daysInYear >= days[numberOfMonth])
 			{
 				numberOfMonth++;
-#if DEBUG
-				Contract.Assert( numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear );
-#endif // DEBUG
+
+				Debug.Assert(numberOfMonth <= 12, numberOfMonth + "<= 12, daysInYear = " + daysInYear);
 			}
 			// compute month and day
-			month = unchecked( ( int )numberOfMonth );
-			day = unchecked( ( int )( daysInYear - days[ numberOfMonth - 1 ] + 1 ) );
+			month = unchecked((int)numberOfMonth);
+			day = unchecked((int)(daysInYear - days[numberOfMonth - 1] + 1));
 		}
 
 		/// <summary>
@@ -494,7 +468,7 @@ public static Timestamp UtcNow
 #else // !NET35 && !NET45 && !NETSTANDARD1_1 && !UNITY && !SILVERLIGHT
 					( now.Ticks / TimeSpan.TicksPerSecond ) - UnixEpochInSeconds,
 #endif // !NET35 && !NET45 && !NETSTANDARD1_1 && !UNITY && !SILVERLIGHT
-					unchecked( ( int )( now.Ticks % 10000000 * 100 ) )
+					unchecked((int)(now.Ticks % 10000000 * 100))
 				);
 			}
 		}
diff --git a/src/MsgPack/Timestamp.ToString.cs b/src/MsgPack/Timestamp.ToString.cs
index 36ed4a429..2c24eb3de 100644
--- a/src/MsgPack/Timestamp.ToString.cs
+++ b/src/MsgPack/Timestamp.ToString.cs
@@ -43,7 +43,7 @@ partial struct Timestamp : IFormattable
 		/// </remarks>
 		public override string ToString()
 		{
-			return this.ToString( null, null );
+			return this.ToString(null, null);
 		}
 
 		/// <summary>
@@ -65,9 +65,9 @@ public override string ToString()
 		///			The round trip format is <c>yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffff'Z'</c> which 'fffffffff' nanoseconds. 
 		///		</para>
 		/// </remarks>
-		public string ToString( IFormatProvider formatProvider )
+		public string ToString(IFormatProvider formatProvider)
 		{
-			return this.ToString( null, formatProvider );
+			return this.ToString(null, formatProvider);
 		}
 
 		/// <summary>
@@ -92,11 +92,13 @@ public string ToString( IFormatProvider formatProvider )
 		///			this overload uses <c>null</c> for <c>formatProvider</c> parameter.
 		///		</para>
 		/// </remarks>
-		public string ToString( string format )
+		public string ToString(string format)
 		{
-			return this.ToString( format, null );
+			return this.ToString(format, null);
 		}
 
+#warning TODO: TryFormat
+
 		/// <summary>
 		///		Returns a <see cref="String"/> representation of this instance with the default format and the specified format provider.
 		/// </summary>
@@ -128,10 +130,10 @@ public string ToString( string format )
 		///			If you want to ensure interoperability for other implementation, specify <c>"s"</c> and <see cref="CultureInfo.InvariantCulture"/> resepectively.
 		///		</para>
 		/// </remarks>
-		public string ToString( string format, IFormatProvider formatProvider )
+		public string ToString(string? format, IFormatProvider? formatProvider)
 		{
-			var value = new Value( this );
-			return TimestampStringConverter.ToString( format, formatProvider, ref value );
+			var value = new Value(this);
+			return TimestampStringConverter.ToString(format, formatProvider, ref value);
 		}
 	}
 }
diff --git a/src/MsgPack/Timestamp.TryParseExact.cs b/src/MsgPack/Timestamp.TryParseExact.cs
index da1b4c2ca..ca8cdeee8 100644
--- a/src/MsgPack/Timestamp.TryParseExact.cs
+++ b/src/MsgPack/Timestamp.TryParseExact.cs
@@ -1,33 +1,8 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 using System.Globalization;
 
 namespace MsgPack
@@ -67,9 +42,9 @@ partial struct Timestamp
 		///		The specified <paramref name="format"/> is not supported.
 		///		Or the specified <paramref name="styles"/> has invalid combination.
 		/// </exception>
-		public static bool TryParseExact( string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result )
+		public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result)
 		{
-			return TryParseExactCore( input, format, formatProvider, styles, out result ) == TimestampParseResult.Success;
+			return TryParseExactCore(input, format, formatProvider, styles, out result) == TimestampParseResult.Success;
 		}
 
 		/// <summary>
@@ -105,90 +80,90 @@ public static bool TryParseExact( string input, string format, IFormatProvider f
 		///		The specified <paramref name="formats"/> is empty.
 		///		Or the specified <paramref name="styles"/> has invalid combination.
 		/// </exception>
-		public static bool TryParseExact( string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result )
+		public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result)
 		{
-			return TryParseExactCore( input, formats, formatProvider, styles, out result ) == TimestampParseResult.Success;
+			return TryParseExactCore(input, formats, formatProvider, styles, out result) == TimestampParseResult.Success;
 		}
 
-		private static TimestampParseResult TryParseExactCore( string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result )
+		private static TimestampParseResult TryParseExactCore(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result)
 		{
-			ValidateParseInput( input );
+			ValidateParseInput(input);
 
-			if ( input.Length == 0 )
+			if (input.Length == 0)
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.EmptyInput;
 			}
 
-			if ( format == null )
+			if (format == null)
 			{
-				throw new ArgumentNullException( "format" );
+				throw new ArgumentNullException("format");
 			}
 
-			if ( format.Length == 0 )
+			if (format.Length == 0)
 			{
-				throw new ArgumentException( "The 'format' must not be empty.", "format" );
+				throw new ArgumentException("The 'format' must not be empty.", "format");
 			}
 
-			ValidateParseStyles( styles );
+			ValidateParseStyles(styles);
 
-			var error = TimestampStringConverter.TryParseExact( input, format, formatProvider, styles, out result );
-			if ( error == TimestampParseResult.UnsupportedFormat )
+			var error = TimestampStringConverter.TryParseExact(input, format, formatProvider, styles, out result);
+			if (error == TimestampParseResult.UnsupportedFormat)
 			{
 				// UnsupportedFormat should throw Exception instead of returning false.
-				HandleParseResult( error, "Cannot parse specified input with specified format." );
+				HandleParseResult(error, "Cannot parse specified input with specified format.");
 			}
 
 			return error;
 		}
 
-		private static TimestampParseResult TryParseExactCore( string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result )
+		private static TimestampParseResult TryParseExactCore(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result)
 		{
-			ValidateParseInput( input );
+			ValidateParseInput(input);
 
-			if ( formats == null )
+			if (formats == null)
 			{
-				throw new ArgumentNullException( "formats" );
+				throw new ArgumentNullException("formats");
 			}
 
-			if ( formats.Length == 0 )
+			if (formats.Length == 0)
 			{
-				throw new ArgumentException( "The 'formats' must not be empty.", "formats" );
+				throw new ArgumentException("The 'formats' must not be empty.", "formats");
 			}
 
-			ValidateParseStyles( styles );
+			ValidateParseStyles(styles);
 
-			if ( input.Length == 0 )
+			if (input.Length == 0)
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.EmptyInput;
 			}
 
-			foreach ( var format in formats )
+			foreach (var format in formats)
 			{
-				if ( TimestampStringConverter.TryParseExact( input, format, formatProvider, styles, out result ) == TimestampParseResult.Success )
+				if (TimestampStringConverter.TryParseExact(input, format, formatProvider, styles, out result) == TimestampParseResult.Success)
 				{
 					return TimestampParseResult.Success;
 				}
 			}
 
-			result = default( Timestamp );
+			result = default(Timestamp);
 			return TimestampParseResult.NoMatchedFormats;
 		}
 
-		private static void ValidateParseInput( string input )
+		private static void ValidateParseInput(string input)
 		{
-			if ( input == null )
+			if (input == null)
 			{
-				throw new ArgumentNullException( "input" );
+				throw new ArgumentNullException("input");
 			}
 		}
 
-		private static void ValidateParseStyles( DateTimeStyles styles )
+		private static void ValidateParseStyles(DateTimeStyles styles)
 		{
-			if ( styles != DateTimeStyles.None && ( styles & ~( DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite ) ) != 0 )
+			if (styles != DateTimeStyles.None && (styles & ~(DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite)) != 0)
 			{
-				throw new ArgumentException( "Timestamp currently only support DateTimeStyles.None, DateTimeStyles.AllowLeadingWhite, and DateTimeStyles.AllowTrailingWhite.", "styles" );
+				throw new ArgumentException("Timestamp currently only support DateTimeStyles.None, DateTimeStyles.AllowLeadingWhite, and DateTimeStyles.AllowTrailingWhite.", "styles");
 			}
 		}
 	}
diff --git a/src/MsgPack/Timestamp.cs b/src/MsgPack/Timestamp.cs
index 8043dff75..9c3d268cc 100644
--- a/src/MsgPack/Timestamp.cs
+++ b/src/MsgPack/Timestamp.cs
@@ -1,26 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -47,17 +27,17 @@ public partial struct Timestamp
 		/// <summary>
 		///		An instance represents zero. This is 1970-01-01T00:00:00.000000000.
 		/// </summary>
-		public static readonly Timestamp Zero = new Timestamp( 0, 0 );
+		public static readonly Timestamp Zero = new Timestamp(0, 0);
 
 		/// <summary>
 		///		An instance represents minimum value of this instance. This is <c>[<see cref="Int64.MinValue"/>, 0]</c> in encoded format.
 		/// </summary>
-		public static readonly Timestamp MinValue = new Timestamp( Int64.MinValue, 0 );
+		public static readonly Timestamp MinValue = new Timestamp(Int64.MinValue, 0);
 
 		/// <summary>
 		///		An instance represents maximum value of this instance. This is <c>[<see cref="Int64.MaxValue"/>, 999999999]</c> in encoded format.
 		/// </summary>
-		public static readonly Timestamp MaxValue = new Timestamp( Int64.MaxValue, MaxNanoSeconds );
+		public static readonly Timestamp MaxValue = new Timestamp(Int64.MaxValue, MaxNanoSeconds);
 
 		private static readonly int[] LastDays =
 			new[]
@@ -99,31 +79,31 @@ public partial struct Timestamp
 		/// <exception cref="ArgumentOutOfRangeException">
 		///		<paramref name="nanoseconds"/> is negative or is greater than <c>999,999,999</c> exclusive.
 		/// </exception>
-		public Timestamp( long unixEpochSeconds, int nanoseconds )
+		public Timestamp(long unixEpochSeconds, int nanoseconds)
 		{
-			if ( nanoseconds > MaxNanoSeconds || nanoseconds < 0 )
+			if (nanoseconds > MaxNanoSeconds || nanoseconds < 0)
 			{
-				throw new ArgumentOutOfRangeException( "nanoseconds", "nanoseconds must be non negative value and lessor than 999,999,999." );
+				throw new ArgumentOutOfRangeException("nanoseconds", "nanoseconds must be non negative value and lessor than 999,999,999.");
 			}
 
 			this.unixEpochSeconds = unixEpochSeconds;
-			this.nanoseconds = unchecked( ( uint )nanoseconds );
+			this.nanoseconds = unchecked((uint)nanoseconds);
 		}
 
-		internal static Timestamp FromComponents( ref Value value, bool isLeapYear )
+		internal static Timestamp FromComponents(ref Value value, bool isLeapYear)
 		{
 			long epoc;
 			checked
 			{
-				var days = YearsToDaysOfNewYear( value.Year ) + ToDaysOffsetFromNewYear( value.Month, value.Day, isLeapYear ) - Timestamp.UnixEpochInSeconds / Timestamp.SecondsPerDay;
+				var days = YearsToDaysOfNewYear(value.Year) + ToDaysOffsetFromNewYear(value.Month, value.Day, isLeapYear) - Timestamp.UnixEpochInSeconds / Timestamp.SecondsPerDay;
 				// First set time offset to avoid overflow.
 				epoc = value.Hour * 60 * 60;
 				epoc += value.Minute * 60;
 				epoc += value.Second;
-				if ( days < 0 )
+				if (days < 0)
 				{
 					// Avoid right side overflow.
-					epoc += ( days + 1 ) * Timestamp.SecondsPerDay;
+					epoc += (days + 1) * Timestamp.SecondsPerDay;
 					epoc -= Timestamp.SecondsPerDay;
 				}
 				else
@@ -132,38 +112,38 @@ internal static Timestamp FromComponents( ref Value value, bool isLeapYear )
 				}
 			}
 
-			return new Timestamp( epoc, unchecked( ( int )value.Nanoseconds ) );
+			return new Timestamp(epoc, unchecked((int)value.Nanoseconds));
 		}
 
-		private static long YearsToDaysOfNewYear( long years )
+		private static long YearsToDaysOfNewYear(long years)
 		{
 			long remainOf400Years, remainOf100Years, remainOf4Years;
 
 			// For AD, uses offset from 0001, so decrement 1 at first.
-			var numberOf400Years = DivRem( years > 0 ? ( years - 1 ) : years, 400, out remainOf400Years );
-			var numberOf100Years = DivRem( remainOf400Years, 100, out remainOf100Years );
-			var numberOf4Years = DivRem( remainOf100Years, 4, out remainOf4Years );
+			var numberOf400Years = DivRem(years > 0 ? (years - 1) : years, 400, out remainOf400Years);
+			var numberOf100Years = DivRem(remainOf400Years, 100, out remainOf100Years);
+			var numberOf4Years = DivRem(remainOf100Years, 4, out remainOf4Years);
 			var days =
 				DaysPer400Years * numberOf400Years +
 				DaysPer100Years * numberOf100Years +
 				DaysPer4Years * numberOf4Years +
 				DaysPerYear * remainOf4Years;
-			if ( years <= 0 )
+			if (years <= 0)
 			{
 				// For BC, subtract year 0000 offset.
-				days -= ( DaysPerYear + 1 );
+				days -= (DaysPerYear + 1);
 			}
 
 			return days;
 		}
 
-		private static int ToDaysOffsetFromNewYear( int month, int day, bool isLeapYear )
+		private static int ToDaysOffsetFromNewYear(int month, int day, bool isLeapYear)
 		{
 			var result = -1; // 01-01 should be 0, so starts with -1.
-			for ( var i = 1; i < month; i++ )
+			for (var i = 1; i < month; i++)
 			{
-				result += LastDays[ i ];
-				if ( i == 2 )
+				result += LastDays[i];
+				if (i == 2)
 				{
 					result += isLeapYear ? 29 : 28;
 				}
@@ -184,9 +164,9 @@ internal static long DivRem( long dividend, long divisor, out long remainder )
 
 #else // NETSTANDARD1_1 || NETSTANDARD1_3 || SILVERLIGHT
 
-		internal static long DivRem( long dividend, long divisor, out long remainder )
+		internal static long DivRem(long dividend, long divisor, out long remainder)
 		{
-			return Math.DivRem( dividend, divisor, out remainder );
+			return Math.DivRem(dividend, divisor, out remainder);
 		}
 
 #endif // NETSTANDARD1_1 || NETSTANDARD1_3 || SILVERLIGHT
@@ -206,10 +186,10 @@ struct Value
 			public int Second;
 			public uint Nanoseconds;
 
-			public Value( Timestamp encoded )
+			public Value(Timestamp encoded)
 			{
 				int dayOfYear;
-				encoded.GetDatePart( out this.Year, out this.Month, out this.Day, out dayOfYear );
+				encoded.GetDatePart(out this.Year, out this.Month, out this.Day, out dayOfYear);
 				this.Hour = encoded.Hour;
 				this.Minute = encoded.Minute;
 				this.Second = encoded.Second;
@@ -217,7 +197,7 @@ public Value( Timestamp encoded )
 			}
 
 #if DEBUG
-			public Value( long year, int month, int day, int hour, int minute, int second, uint nanoseconds )
+			public Value(long year, int month, int day, int hour, int minute, int second, uint nanoseconds)
 			{
 				this.Year = year;
 				this.Month = month;
diff --git a/src/MsgPack/TimestampParseResult.cs b/src/MsgPack/TimestampParseResult.cs
index 518022df1..ba2cb1944 100644
--- a/src/MsgPack/TimestampParseResult.cs
+++ b/src/MsgPack/TimestampParseResult.cs
@@ -1,38 +1,13 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack
 {
 	/// <summary>
 	///		Represents internal <see cref="TimestampStringConverter.TryParseExact"/> result.
 	/// </summary>
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	enum TimestampParseResult
+	internal enum TimestampParseResult
 	{
 		Success = 0,
 
diff --git a/src/MsgPack/TimestampStringConverter.Parse.cs b/src/MsgPack/TimestampStringConverter.Parse.cs
index e7f5e351e..997a464b6 100644
--- a/src/MsgPack/TimestampStringConverter.Parse.cs
+++ b/src/MsgPack/TimestampStringConverter.Parse.cs
@@ -1,154 +1,138 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Globalization;
 
 namespace MsgPack
 {
-	partial class TimestampStringConverter
+	internal partial class TimestampStringConverter
 	{
 		// Currently, custom format and normal date time format except 'o' or 'O' 's' are NOT supported.
-		public static TimestampParseResult TryParseExact( string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result )
+		public static TimestampParseResult TryParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result)
 		{
-			if ( format != "o" && format != "O" && format != "s" )
+			if (format != "o" && format != "O" && format != "s")
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.UnsupportedFormat;
 			}
 
-			var numberFormat = NumberFormatInfo.GetInstance( formatProvider );
+			var numberFormat = NumberFormatInfo.GetInstance(formatProvider);
 
 			var position = 0;
-			if ( !ParseWhitespace( input, ref position, ( styles & DateTimeStyles.AllowLeadingWhite ) != 0, /* isTrailing */false ) )
+			if (!ParseWhitespace(input, ref position, (styles & DateTimeStyles.AllowLeadingWhite) != 0, /* isTrailing */false))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.LeadingWhitespaceNotAllowed;
 			}
 
 			long year;
-			if ( !ParseYear( input, ref position, numberFormat, out year ) )
+			if (!ParseYear(input, ref position, numberFormat, out year))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidYear;
 			}
 
-			if ( !ParseDelimiter( input, ref position, DateDelimiter ) )
+			if (!ParseDelimiter(input, ref position, DateDelimiter))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidYearMonthDeilimiter;
 			}
 
-			var isLeapYear = Timestamp.IsLeapYearInternal( year );
+			var isLeapYear = Timestamp.IsLeapYearInternal(year);
 
 			int month;
-			if ( !ParseDigitRange( input, 2, ref position, 1, 12, out month ) )
+			if (!ParseDigitRange(input, 2, ref position, 1, 12, out month))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidMonth;
 			}
 
-			if ( !ParseDelimiter( input, ref position, DateDelimiter ) )
+			if (!ParseDelimiter(input, ref position, DateDelimiter))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidMonthDayDelimiter;
 			}
 
 			int day;
-			if ( !ParseDay( input, ref position, month, isLeapYear, out day ) )
+			if (!ParseDay(input, ref position, month, isLeapYear, out day))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidDay;
 			}
 
-			if ( !ParseDelimiter( input, ref position, DateTimeDelimiter ) )
+			if (!ParseDelimiter(input, ref position, DateTimeDelimiter))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidDateTimeDelimiter;
 			}
 
 			int hour;
-			if ( !ParseDigitRange( input, 2, ref position, 0, 23, out hour ) )
+			if (!ParseDigitRange(input, 2, ref position, 0, 23, out hour))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidHour;
 			}
 
-			if ( !ParseDelimiter( input, ref position, TimeDelimiter ) )
+			if (!ParseDelimiter(input, ref position, TimeDelimiter))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidHourMinuteDelimiter;
 			}
 
 			int minute;
-			if ( !ParseDigitRange( input, 2, ref position, 0, 59, out minute ) )
+			if (!ParseDigitRange(input, 2, ref position, 0, 59, out minute))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidMinute;
 			}
 
-			if ( !ParseDelimiter( input, ref position, TimeDelimiter ) )
+			if (!ParseDelimiter(input, ref position, TimeDelimiter))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidMinuteSecondDelimiter;
 			}
 
 			int second;
-			if ( !ParseDigitRange( input, 2, ref position, 0, 59, out second ) )
+			if (!ParseDigitRange(input, 2, ref position, 0, 59, out second))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.InvalidSecond;
 			}
 
 			var nanosecond = 0;
-			if ( format != "s" )
+			if (format != "s")
 			{
 				// "o" or "O"
-				if ( !ParseDelimiter( input, ref position, SubsecondDelimiter ) )
+				if (!ParseDelimiter(input, ref position, SubsecondDelimiter))
 				{
-					result = default( Timestamp );
+					result = default(Timestamp);
 					return TimestampParseResult.InvalidSubsecondDelimiter;
 				}
 
-				if ( !ParseDigitRange( input, 9, ref position, 0, 999999999, out nanosecond ) )
+				if (!ParseDigitRange(input, 9, ref position, 0, 999999999, out nanosecond))
 				{
-					result = default( Timestamp );
+					result = default(Timestamp);
 					return TimestampParseResult.InvalidNanoSecond;
 				}
 			}
 
-			if ( !ParseDelimiter( input, ref position, UtcSign ) )
+			if (!ParseDelimiter(input, ref position, UtcSign))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.MissingUtcSign;
 			}
 
-			if ( !ParseWhitespace( input, ref position, ( styles & DateTimeStyles.AllowTrailingWhite ) != 0, /* isTrailing */true ) )
+			if (!ParseWhitespace(input, ref position, (styles & DateTimeStyles.AllowTrailingWhite) != 0, /* isTrailing */true))
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.TrailingWhitespaceNotAllowed;
 			}
 
-			if ( position != input.Length )
+			if (position != input.Length)
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.ExtraCharactors;
 			}
 
@@ -159,34 +143,34 @@ public static TimestampParseResult TryParseExact( string input, string format, I
 			components.Hour = hour;
 			components.Minute = minute;
 			components.Second = second;
-			components.Nanoseconds = unchecked( ( uint )nanosecond );
+			components.Nanoseconds = unchecked((uint)nanosecond);
 
 			try
 			{
-				result = Timestamp.FromComponents( ref components, isLeapYear );
+				result = Timestamp.FromComponents(ref components, isLeapYear);
 			}
-			catch ( OverflowException )
+			catch (OverflowException)
 			{
-				result = default( Timestamp );
+				result = default(Timestamp);
 				return TimestampParseResult.YearOutOfRange;
 			}
 
 			return TimestampParseResult.Success;
 		}
 
-		private static bool ParseWhitespace( string input, ref int position, bool allowWhitespace, bool isTrailing )
+		private static bool ParseWhitespace(string input, ref int position, bool allowWhitespace, bool isTrailing)
 		{
-			if ( input.Length <= position )
+			if (input.Length <= position)
 			{
 				return isTrailing;
 			}
 
-			if ( !allowWhitespace )
+			if (!allowWhitespace)
 			{
-				return !Char.IsWhiteSpace( input[ position ] );
+				return !Char.IsWhiteSpace(input[position]);
 			}
 
-			while ( position < input.Length && Char.IsWhiteSpace( input[ position ] ) )
+			while (position < input.Length && Char.IsWhiteSpace(input[position]))
 			{
 				position++;
 			}
@@ -194,14 +178,14 @@ private static bool ParseWhitespace( string input, ref int position, bool allowW
 			return true;
 		}
 
-		private static bool ParseDelimiter( string input, ref int position, char delimiter )
+		private static bool ParseDelimiter(string input, ref int position, char delimiter)
 		{
-			if ( input.Length <= position )
+			if (input.Length <= position)
 			{
 				return false;
 			}
 
-			if ( input[ position ] != delimiter )
+			if (input[position] != delimiter)
 			{
 				return false;
 			}
@@ -210,48 +194,48 @@ private static bool ParseDelimiter( string input, ref int position, char delimit
 			return true;
 		}
 
-		private static bool ParseSign( string input, ref int position, NumberFormatInfo numberFormat, out int sign )
+		private static bool ParseSign(string input, ref int position, NumberFormatInfo numberFormat, out int sign)
 		{
-			if ( input.Length <= position )
+			if (input.Length <= position)
 			{
-				sign = default( int );
+				sign = default(int);
 				return false;
 			}
 
-			if ( IsDigit( input[ position ] ) )
+			if (IsDigit(input[position]))
 			{
 				sign = 1;
 				return true;
 			}
 
-			if ( StartsWith( input, position, numberFormat.NegativeSign ) )
+			if (StartsWith(input, position, numberFormat.NegativeSign))
 			{
 				position += numberFormat.NegativeSign.Length;
 				sign = -1;
 				return true;
 			}
 
-			if ( StartsWith( input, position, numberFormat.PositiveSign ) )
+			if (StartsWith(input, position, numberFormat.PositiveSign))
 			{
 				position += numberFormat.NegativeSign.Length;
 				sign = 1;
 				return true;
 			}
 
-			sign = default( int );
+			sign = default(int);
 			return false;
 		}
 
-		private static bool StartsWith( string input, int startIndex, string comparison )
+		private static bool StartsWith(string input, int startIndex, string comparison)
 		{
-			for ( var i = 0; i < comparison.Length; i++ )
+			for (var i = 0; i < comparison.Length; i++)
 			{
-				if ( i + startIndex >= input.Length )
+				if (i + startIndex >= input.Length)
 				{
 					return false;
 				}
 
-				if ( input[ i + startIndex ] != comparison[ i ] )
+				if (input[i + startIndex] != comparison[i])
 				{
 					return false;
 				}
@@ -260,19 +244,19 @@ private static bool StartsWith( string input, int startIndex, string comparison
 			return true;
 		}
 
-		private static bool ParseDigit( string input, int minLength, ref int position, out long digit )
+		private static bool ParseDigit(string input, int minLength, ref int position, out long digit)
 		{
 			var startPosition = position;
 			var bits = 0L;
-			while ( position < input.Length )
+			while (position < input.Length)
 			{
-				var c = input[ position ];
-				if ( !IsDigit( c ) )
+				var c = input[position];
+				if (!IsDigit(c))
 				{
 					break;
 				}
 
-				bits = bits * 10 + ( c - '0' );
+				bits = bits * 10 + (c - '0');
 				position++;
 			}
 
@@ -280,43 +264,43 @@ private static bool ParseDigit( string input, int minLength, ref int position, o
 			return position >= startPosition + minLength;
 		}
 
-		private static bool IsDigit( char c )
+		private static bool IsDigit(char c)
 		{
 			return '0' <= c && c <= '9';
 		}
 
-		private static bool ParseDigitRange( string input, int minLength, ref int position, int min, int max, out int result )
+		private static bool ParseDigitRange(string input, int minLength, ref int position, int min, int max, out int result)
 		{
 			long digit;
-			if ( !ParseDigit( input, minLength, ref position, out digit ) )
+			if (!ParseDigit(input, minLength, ref position, out digit))
 			{
-				result = default( int );
+				result = default(int);
 				return false;
 			}
 
-			if ( digit < min || max < digit )
+			if (digit < min || max < digit)
 			{
-				result = default( int );
+				result = default(int);
 				return false;
 			}
 
-			result = unchecked( ( int )digit );
+			result = unchecked((int)digit);
 			return true;
 		}
 
-		private static bool ParseYear( string input, ref int position, NumberFormatInfo numberFormat, out long year )
+		private static bool ParseYear(string input, ref int position, NumberFormatInfo numberFormat, out long year)
 		{
 			int sign;
-			if ( !ParseSign( input, ref position, numberFormat, out sign ) )
+			if (!ParseSign(input, ref position, numberFormat, out sign))
 			{
-				year = default( long );
+				year = default(long);
 				return false;
 			}
 
 			long digit;
-			if ( !ParseDigit( input, 4, ref position, out digit ) )
+			if (!ParseDigit(input, 4, ref position, out digit))
 			{
-				year = default( long );
+				year = default(long);
 				return false;
 			}
 
@@ -325,24 +309,24 @@ private static bool ParseYear( string input, ref int position, NumberFormatInfo
 			return true;
 		}
 
-		private static bool ParseDay( string input, ref int position, int month, bool isLeapYear, out int day )
+		private static bool ParseDay(string input, ref int position, int month, bool isLeapYear, out int day)
 		{
 			long digit;
-			if ( !ParseDigit( input, 2, ref position, out digit ) )
+			if (!ParseDigit(input, 2, ref position, out digit))
 			{
-				day = default( int );
+				day = default(int);
 				return false;
 			}
 
-			var lastDay = Timestamp.GetLastDay( month, isLeapYear );
+			var lastDay = Timestamp.GetLastDay(month, isLeapYear);
 
-			if ( digit < 1 || lastDay < digit )
+			if (digit < 1 || lastDay < digit)
 			{
-				day = default( int );
+				day = default(int);
 				return false;
 			}
 
-			day = unchecked( ( int )digit );
+			day = unchecked((int)digit);
 			return true;
 		}
 	}
diff --git a/src/MsgPack/TimestampStringConverter.ToString.cs b/src/MsgPack/TimestampStringConverter.ToString.cs
index b695e296a..b94ffdc68 100644
--- a/src/MsgPack/TimestampStringConverter.ToString.cs
+++ b/src/MsgPack/TimestampStringConverter.ToString.cs
@@ -1,22 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Globalization;
@@ -24,57 +8,57 @@
 
 namespace MsgPack
 {
-	partial class TimestampStringConverter
+	internal partial class TimestampStringConverter
 	{
 		private const string DefaultFormat = "o";
 
-		public static string ToString( string format, IFormatProvider formatProvider, ref Timestamp.Value value )
+		public static string ToString(string? format, IFormatProvider? formatProvider, ref Timestamp.Value value)
 		{
-			switch ( format ?? DefaultFormat )
+			switch (format ?? DefaultFormat)
 			{
 				case "o":
 				case "O":
 				{
 					// round-trip
-					return ToIso8601String( formatProvider, /* containsNanoseconds */true, ref value );
+					return ToIso8601String(formatProvider, /* containsNanoseconds */true, ref value);
 				}
 				case "s":
 				{
 					// sortable(ISO-8601)
-					return ToIso8601String( formatProvider, /* containsNanoseconds */false, ref value );
+					return ToIso8601String(formatProvider, /* containsNanoseconds */false, ref value);
 				}
 				default:
 				{
-					throw new ArgumentException( "The specified format is not supported.", "format" );
+					throw new ArgumentException("The specified format is not supported.", "format");
 				}
 			}
 		}
 
-		private static string ToIso8601String( IFormatProvider formatProvider, bool containsNanosecons, ref Timestamp.Value value )
+		private static string ToIso8601String(IFormatProvider? formatProvider, bool containsNanosecons, ref Timestamp.Value value)
 		{
-			var numberFormat = NumberFormatInfo.GetInstance( formatProvider );
+			var numberFormat = NumberFormatInfo.GetInstance(formatProvider);
 
 			// Most cases are yyyy-MM-ddTHH:mm:ss[.fffffffff]Z -- 50 or 60 chars.
-			var buffer = new StringBuilder( 49 + ( containsNanosecons ? 11 : 1 ) );
-			buffer.Append( value.Year.ToString( "0000", formatProvider ) );
-			buffer.Append( DateDelimiter );
-			buffer.Append( value.Month.ToString( "00", formatProvider ) );
-			buffer.Append( DateDelimiter );
-			buffer.Append( value.Day.ToString( "00", formatProvider ) );
-			buffer.Append( DateTimeDelimiter );
-			buffer.Append( value.Hour.ToString( "00", formatProvider ) );
-			buffer.Append( TimeDelimiter );
-			buffer.Append( value.Minute.ToString( "00", formatProvider ) );
-			buffer.Append( TimeDelimiter );
-			buffer.Append( value.Second.ToString( "00", formatProvider ) );
+			var buffer = new StringBuilder(49 + (containsNanosecons ? 11 : 1));
+			buffer.Append(value.Year.ToString("0000", formatProvider));
+			buffer.Append(DateDelimiter);
+			buffer.Append(value.Month.ToString("00", formatProvider));
+			buffer.Append(DateDelimiter);
+			buffer.Append(value.Day.ToString("00", formatProvider));
+			buffer.Append(DateTimeDelimiter);
+			buffer.Append(value.Hour.ToString("00", formatProvider));
+			buffer.Append(TimeDelimiter);
+			buffer.Append(value.Minute.ToString("00", formatProvider));
+			buffer.Append(TimeDelimiter);
+			buffer.Append(value.Second.ToString("00", formatProvider));
 
-			if ( containsNanosecons )
+			if (containsNanosecons)
 			{
-				buffer.Append( SubsecondDelimiter );
-				buffer.Append( value.Nanoseconds.ToString( "000000000", formatProvider ) );
+				buffer.Append(SubsecondDelimiter);
+				buffer.Append(value.Nanoseconds.ToString("000000000", formatProvider));
 			}
 
-			buffer.Append( UtcSign );
+			buffer.Append(UtcSign);
 
 			return buffer.ToString();
 		}
diff --git a/src/MsgPack/TimestampStringConverter.cs b/src/MsgPack/TimestampStringConverter.cs
index 9e80c889a..8d0cb4c18 100644
--- a/src/MsgPack/TimestampStringConverter.cs
+++ b/src/MsgPack/TimestampStringConverter.cs
@@ -1,41 +1,13 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2017-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
-
-using System;
-using System.Globalization;
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack
 {
 	/// <summary>
 	///		An internal <see cref="Timestamp"/> parser and stringifier.
 	/// </summary>
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	static partial class TimestampStringConverter
+	internal static partial class TimestampStringConverter
 	{
 		private const char DateDelimiter = '-';
 		private const char TimeDelimiter = ':';

From 728468b503c061c9ec867b77c844ef899caaabbc Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:33:35 +0900
Subject: [PATCH 77/82] Add v2 extension type conversion methods

---
 src/MsgPack/Timestamp.Conversion.cs | 106 ++++++++++++++++------------
 1 file changed, 61 insertions(+), 45 deletions(-)

diff --git a/src/MsgPack/Timestamp.Conversion.cs b/src/MsgPack/Timestamp.Conversion.cs
index fa6db97ec..2cc9e7774 100644
--- a/src/MsgPack/Timestamp.Conversion.cs
+++ b/src/MsgPack/Timestamp.Conversion.cs
@@ -74,55 +74,47 @@ public DateTimeOffset ToDateTimeOffset()
 		/// <returns>A <see cref="MessagePackExtendedTypeObject"/> which equivalant to this instance.</returns>
 		public MessagePackExtendedTypeObject Encode()
 		{
-			if ( ( this.unixEpochSeconds >> 34 ) != 0 )
+			Span<byte> buffer = stackalloc byte[12];
+			var used = this.Encode(buffer);
+			return MessagePackExtendedTypeObject.Unpack(TypeCode, buffer.Slice(0, used).ToArray());
+		}
+
+		public int Encode(Span<byte> buffer)
+		{
+			if ((this.unixEpochSeconds >> 34) != 0)
 			{
-				// timestamp 96
-				var value = this;
-				var body = new byte[ 12 ];
-				body[ 0 ] = unchecked( ( byte )( ( this.nanoseconds >> 24 ) & 0xFF ) );
-				body[ 1 ] = unchecked( ( byte )( ( this.nanoseconds >> 16 ) & 0xFF ) );
-				body[ 2 ] = unchecked( ( byte )( ( this.nanoseconds >> 8 ) & 0xFF ) );
-				body[ 3 ] = unchecked( ( byte )( ( this.nanoseconds ) & 0xFF ) );
-				body[ 4 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 56 ) & 0xFF ) );
-				body[ 5 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 48 ) & 0xFF ) );
-				body[ 6 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 40 ) & 0xFF ) );
-				body[ 7 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 32 ) & 0xFF ) );
-				body[ 8 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 24 ) & 0xFF ) );
-				body[ 9 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 16 ) & 0xFF ) );
-				body[ 10 ] = unchecked( ( byte )( ( this.unixEpochSeconds >> 8 ) & 0xFF ) );
-				body[ 11 ] = unchecked( ( byte )( this.unixEpochSeconds & 0xFF ) );
+				if (buffer.Length < 12)
+				{
+					Throw.TooSmallBuffer(nameof(buffer), 12);
+				}
 
-				return MessagePackExtendedTypeObject.Unpack( TypeCode, body );
+				// timestamp 96
+				BinaryPrimitives.WriteUInt32BigEndian(buffer, this.nanoseconds);
+				buffer = buffer.Slice(4);
+				BinaryPrimitives.WriteInt64BigEndian(buffer, this.unixEpochSeconds);
+				return 12;
 			}
 			else
 			{
-				var encoded = ( ( ( ulong )this.nanoseconds ) << 34 ) | unchecked( ( ulong )this.unixEpochSeconds );
-				if ( ( encoded & 0xFFFFFFFF00000000L ) == 0 )
+				var encoded = (((ulong)this.nanoseconds) << 34) | unchecked((ulong)this.unixEpochSeconds);
+				if ((encoded & 0xFFFFFFFF00000000L) == 0)
 				{
+					if (buffer.Length < 4)
+					{
+						Throw.TooSmallBuffer(nameof(buffer), 4);
+					}
+
 					// timestamp 32
-					var value = unchecked( ( uint )encoded );
-					var body = new byte[ 4 ];
-					body[ 0 ] = unchecked( ( byte )( ( encoded >> 24 ) & 0xFF ) );
-					body[ 1 ] = unchecked( ( byte )( ( encoded >> 16 ) & 0xFF ) );
-					body[ 2 ] = unchecked( ( byte )( ( encoded >> 8 ) & 0xFF ) );
-					body[ 3 ] = unchecked( ( byte )( encoded & 0xFF ) );
+					BinaryPrimitives.WriteUInt32BigEndian(buffer, unchecked((uint)encoded));
 
-					return MessagePackExtendedTypeObject.Unpack( TypeCode, body );
+					return 4;
 				}
 				else
 				{
 					// timestamp 64
-					var body = new byte[ 8 ];
-					body[ 0 ] = unchecked( ( byte )( ( encoded >> 56 ) & 0xFF ) );
-					body[ 1 ] = unchecked( ( byte )( ( encoded >> 48 ) & 0xFF ) );
-					body[ 2 ] = unchecked( ( byte )( ( encoded >> 40 ) & 0xFF ) );
-					body[ 3 ] = unchecked( ( byte )( ( encoded >> 32 ) & 0xFF ) );
-					body[ 4 ] = unchecked( ( byte )( ( encoded >> 24 ) & 0xFF ) );
-					body[ 5 ] = unchecked( ( byte )( ( encoded >> 16 ) & 0xFF ) );
-					body[ 6 ] = unchecked( ( byte )( ( encoded >> 8 ) & 0xFF ) );
-					body[ 7 ] = unchecked( ( byte )( encoded & 0xFF ) );
+					BinaryPrimitives.WriteUInt64BigEndian(buffer, encoded);
 
-					return MessagePackExtendedTypeObject.Unpack( TypeCode, body );
+					return 8;
 				}
 			}
 		}
@@ -193,34 +185,58 @@ public static Timestamp FromDateTimeOffset(DateTimeOffset value)
 		///			<item>Its nanoseconds part is between 0 and 999,999,999.</item>
 		///		</list>
 		/// </remarks>
-		public static Timestamp Decode( MessagePackExtendedTypeObject value )
+		public static Timestamp Decode(MessagePackExtendedTypeObject value)
 		{
-			if ( value.TypeCode != TypeCode )
+			if (value.TypeCode != TypeCode)
 			{
-				throw new ArgumentException( "The value's type code must be 0xFF.", "value" );
+				Throw.InvalidTimestampTypeCode(value.TypeCode, nameof(value));
 			}
 
-			switch( value.Body.Length )
+			return DecodeCore(new ReadOnlySequence<byte>(value.Body));
+		}
+			
+
+		public static Timestamp Decode(ExtensionTypeObject value)
+		{
+			if (value.Type.Tag != unchecked((sbyte)TypeCode))
+			{
+				Throw.InvalidTimestampTypeCode(value.Type.Tag, nameof(value));
+			}
+
+			return DecodeCore(value.Body);
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static Timestamp DecodeCore(in ReadOnlySequence<byte> body)
+		{ 
+			switch (body.Length)
 			{
 				case 4:
 				{
 					// timespan32 format
-					return new Timestamp( BigEndianBinary.ToUInt32( value.Body, 0 ), 0 );
+					Span<byte> buffer = stackalloc byte[4];
+					body.CopyTo(buffer);
+					return new Timestamp(BinaryPrimitives.ReadUInt32BigEndian(buffer), 0);
 				}
 				case 8:
 				{
 					// timespan64 format
-					var payload = BigEndianBinary.ToUInt64( value.Body, 0 );
-					return new Timestamp( unchecked( ( long )( payload & 0x00000003ffffffffL ) ), unchecked( ( int )( payload >> 34 ) ) );
+					Span<byte> buffer = stackalloc byte[8];
+					body.CopyTo(buffer);
+					var payload = BinaryPrimitives.ReadUInt64BigEndian(buffer);
+					return new Timestamp(unchecked((long)(payload & 0x00000003ffffffffL)), unchecked((int)(payload >> 34)));
 				}
 				case 12:
 				{
 					// timespan96 format
-					return new Timestamp( BigEndianBinary.ToInt64( value.Body, sizeof( int ) ), unchecked( ( int )BigEndianBinary.ToUInt32( value.Body, 0 ) ) );
+					Span<byte> buffer = stackalloc byte[12];
+					body.CopyTo(buffer);
+					return new Timestamp(BinaryPrimitives.ReadInt64BigEndian(buffer.Slice(sizeof(int))), BinaryPrimitives.ReadInt32BigEndian(buffer));
 				}
 				default:
 				{
-					throw new ArgumentException( "The value's length is not valid.", "value" );
+					Throw.InvalidTimestampLength(body.Length, "value");
+					return default; // Never reaches
 				}
 			}
 		}

From a949c97a6dfdac26d76921aede2cad8fec8c7c09 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:35:39 +0900
Subject: [PATCH 78/82] FIX binding options removal

---
 .../Serialization/SerializationContext.cs     | 21 -------------------
 1 file changed, 21 deletions(-)

diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 0b78adec7..7deb8eafe 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -117,27 +117,6 @@ public static SerializationContext Default
 
 		private readonly object _generationLock;
 
-		private readonly BindingOptions _bindingOptions;
-
-		/// <summary>
-		///		Gets the option settings for binding of type with serializer for field/property.
-		/// </summary>
-		/// <value>
-		///		The option settings for binding of type's property/field in serializer generation.
-		///		This value will not be <c>null</c>.
-		/// </value>
-		public BindingOptions BindingOptions
-		{
-			get
-			{
-#if DEBUG
-				Contract.Ensures( Contract.Result<BindingOptions>() != null );
-#endif // DEBUG
-
-				return this._bindingOptions;
-			}
-		}
-
 		/// <summary>
 		///		Gets the current <see cref="SerializerRepository"/>.
 		/// </summary>

From ceba0640aa62f268d0eb7c43be151fadc3ec0702 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 21:36:37 +0900
Subject: [PATCH 79/82] TODO REBASE Add
 DateTimeConversionMethod.Iso8601ExtendedFormat

This is required for JSON codec
---
 src/MsgPack/Serialization/SerializationContext.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/MsgPack/Serialization/SerializationContext.cs b/src/MsgPack/Serialization/SerializationContext.cs
index 7deb8eafe..7ec31d418 100644
--- a/src/MsgPack/Serialization/SerializationContext.cs
+++ b/src/MsgPack/Serialization/SerializationContext.cs
@@ -358,6 +358,7 @@ public DateTimeConversionMethod DefaultDateTimeConversionMethod
 					case DateTimeConversionMethod.Native:
 					case DateTimeConversionMethod.UnixEpoc:
 					case DateTimeConversionMethod.Timestamp:
+					case DateTimeConversionMethod.Iso8601ExtendedFormat:
 					{
 						break;
 					}

From 1e5d373340e86e39f2b1c112ada9487a496be821 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 23:00:30 +0900
Subject: [PATCH 80/82] FIX porting primitive types

---
 src/MsgPack.Abstraction/MessagePackObject.cs | 1765 ++++++++++++++++++
 src/MsgPack.Abstraction/MessagePackObject.tt |  723 +++++++
 src/MsgPack/MessagePackObjectDictionary.cs   |    2 +-
 3 files changed, 2489 insertions(+), 1 deletion(-)
 create mode 100644 src/MsgPack.Abstraction/MessagePackObject.cs
 create mode 100644 src/MsgPack.Abstraction/MessagePackObject.tt

diff --git a/src/MsgPack.Abstraction/MessagePackObject.cs b/src/MsgPack.Abstraction/MessagePackObject.cs
new file mode 100644
index 000000000..8983d02e7
--- /dev/null
+++ b/src/MsgPack.Abstraction/MessagePackObject.cs
@@ -0,0 +1,1765 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+#nullable enable
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace MsgPack
+{
+	/// <summary>
+	///		Represents deserialized object of MsgPack.
+	/// </summary>
+	[StructLayout(LayoutKind.Auto)]
+	public partial struct MessagePackObject : IEquatable<MessagePackObject>
+	{
+		#region -- Constructors --
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Boolean"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Boolean value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = value ? (ulong)1 : 0;
+			this._handleOrTypeCode = BooleanTypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Byte"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Byte value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = value;
+			this._handleOrTypeCode = ByteTypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="SByte"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		[CLSCompliant(false)]
+		public MessagePackObject(SByte value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)value);
+			this._handleOrTypeCode = SByteTypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Int16"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Int16 value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)value);
+			this._handleOrTypeCode = Int16TypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="UInt16"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		[CLSCompliant(false)]
+		public MessagePackObject(UInt16 value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = value;
+			this._handleOrTypeCode = UInt16TypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Int32"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Int32 value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)value);
+			this._handleOrTypeCode = Int32TypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="UInt32"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		[CLSCompliant(false)]
+		public MessagePackObject(UInt32 value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = value;
+			this._handleOrTypeCode = UInt32TypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Int64"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Int64 value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)value);
+			this._handleOrTypeCode = Int64TypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="UInt64"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		[CLSCompliant(false)]
+		public MessagePackObject(UInt64 value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = value;
+			this._handleOrTypeCode = UInt64TypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Single"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Single value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)Binary.ToBits(value));
+			this._handleOrTypeCode = SingleTypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="Double"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(Double value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)BitConverter.DoubleToInt64Bits(value));
+			this._handleOrTypeCode = DoubleTypeCode;
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <remarks>
+		///		This constructor invokes <see cref="MessagePackObject(Byte[],Boolean)" /> with <c>false</c>, that means if you pass tha bytes array which is valid utf-8, resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(String value)
+			: this(value, false) { }
+
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <param name="isBinary"><c>true</c> if <paramref name="value"/> always should be binary; <c>false</c>, otherwise.</param>
+		/// <remarks>
+		///		When the <paramref name="isBinary" /> is <c>true</c>, then resulting object represents binary even if the <paramref name="value"/> is valid utf-8 sequence,
+		///		that is, its <see cref="UnderlyingType" /> should be <see cref="Byte" />[].
+		///		On the other hand, when  contrast, the <paramref name="isBinary" /> is <c>false</c>, and if the <paramref name="value"/> is valid utf-8, 
+		///		then the resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(String value, bool isBinary)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			if (value == null)
+			{
+				this._handleOrTypeCode = null;
+			}
+			else
+			{
+				this._handleOrTypeCode = new MessagePackString(value);
+			}
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <remarks>
+		///		This constructor invokes <see cref="MessagePackObject(Byte[],Boolean)" /> with <c>false</c>, that means if you pass tha bytes array which is valid utf-8, resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(Byte[] value)
+			: this(value, false) { }
+
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <param name="isBinary"><c>true</c> if <paramref name="value"/> always should be binary; <c>false</c>, otherwise.</param>
+		/// <remarks>
+		///		When the <paramref name="isBinary" /> is <c>true</c>, then resulting object represents binary even if the <paramref name="value"/> is valid utf-8 sequence,
+		///		that is, its <see cref="UnderlyingType" /> should be <see cref="Byte" />[].
+		///		On the other hand, when  contrast, the <paramref name="isBinary" /> is <c>false</c>, and if the <paramref name="value"/> is valid utf-8, 
+		///		then the resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(Byte[] value, bool isBinary)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			if (value == null)
+			{
+				this._handleOrTypeCode = null;
+			}
+			else
+			{
+				this._handleOrTypeCode = new MessagePackString(value, isBinary);
+			}
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <remarks>
+		///		This constructor invokes <see cref="MessagePackObject(Byte[],Boolean)" /> with <c>false</c>, that means if you pass tha bytes array which is valid utf-8, resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(ReadOnlyMemory<byte> value)
+			: this(value, false) { }
+
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <param name="isBinary"><c>true</c> if <paramref name="value"/> always should be binary; <c>false</c>, otherwise.</param>
+		/// <remarks>
+		///		When the <paramref name="isBinary" /> is <c>true</c>, then resulting object represents binary even if the <paramref name="value"/> is valid utf-8 sequence,
+		///		that is, its <see cref="UnderlyingType" /> should be <see cref="Byte" />[].
+		///		On the other hand, when  contrast, the <paramref name="isBinary" /> is <c>false</c>, and if the <paramref name="value"/> is valid utf-8, 
+		///		then the resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(ReadOnlyMemory<byte> value, bool isBinary)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._handleOrTypeCode = new MessagePackString(value, false);
+		}
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <remarks>
+		///		This constructor invokes <see cref="MessagePackObject(Byte[],Boolean)" /> with <c>false</c>, that means if you pass tha bytes array which is valid utf-8, resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(ReadOnlyMemory<char> value)
+			: this(value, false) { }
+
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <param name="isBinary"><c>true</c> if <paramref name="value"/> always should be binary; <c>false</c>, otherwise.</param>
+		/// <remarks>
+		///		When the <paramref name="isBinary" /> is <c>true</c>, then resulting object represents binary even if the <paramref name="value"/> is valid utf-8 sequence,
+		///		that is, its <see cref="UnderlyingType" /> should be <see cref="Byte" />[].
+		///		On the other hand, when  contrast, the <paramref name="isBinary" /> is <c>false</c>, and if the <paramref name="value"/> is valid utf-8, 
+		///		then the resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public MessagePackObject(ReadOnlyMemory<char> value, bool isBinary)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._handleOrTypeCode = new MessagePackString(value);
+		}
+
+#pragma warning disable 0618 // obsolete
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="MessagePackExtendedTypeObject"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(MessagePackExtendedTypeObject value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = value.TypeCode;
+			this._handleOrTypeCode = value.Body;
+		}
+
+#pragma warning restore 0618 // obsolete
+		/// <summary>
+		///		Initializes a new instance of the <see cref="MessagePackObject"/> type which wraps <see cref="ExtensionTypeObject"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="MessagePackObject"/> value to be wrapped.</param>
+		public MessagePackObject(ExtensionTypeObject value)
+		{
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			this._value = unchecked((ulong)value.Type.Tag);
+			this._handleOrTypeCode = value.Body;
+		}
+
+		#endregion -- Constructors --
+
+		#region -- Primitive Type Conversion Methods --
+
+		/// <summary>
+		///		Convert this instance to <see cref="Boolean" /> instance.
+		/// </summary>
+		/// <returns><see cref="Boolean" /> instance corresponds to this instance.</returns>
+		public Boolean AsBoolean()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Boolean>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean)
+			{
+				ThrowInvalidTypeAs<bool>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			return this._value != 0;
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Byte" /> instance.
+		/// </summary>
+		/// <returns><see cref="Byte" /> instance corresponds to this instance.</returns>
+		public Byte AsByte()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Byte>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Byte>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)Byte.MinValue;
+					const long maxValue = (long)Byte.MaxValue;
+					
+					long asInt64 = unchecked((long)this._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<Byte>(this);
+					}
+
+					return unchecked((Byte)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Byte.MaxValue);
+					if(maxValue < this._value)
+					{
+						ThrowInvalidTypeAs<Byte>(this);
+					}
+					
+					return (Byte)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Byte)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Byte)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Byte>(this);
+				return default(Byte); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="SByte" /> instance.
+		/// </summary>
+		/// <returns><see cref="SByte" /> instance corresponds to this instance.</returns>
+		[CLSCompliant(false)]
+		public SByte AsSByte()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<SByte>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<SByte>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)SByte.MinValue;
+					const long maxValue = (long)SByte.MaxValue;
+					
+					long asInt64 = unchecked((long)this._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<SByte>(this);
+					}
+
+					return unchecked((SByte)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)SByte.MaxValue);
+					if(maxValue < this._value)
+					{
+						ThrowInvalidTypeAs<SByte>(this);
+					}
+					
+					return (SByte)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (SByte)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (SByte)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<SByte>(this);
+				return default(SByte); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Int16" /> instance.
+		/// </summary>
+		/// <returns><see cref="Int16" /> instance corresponds to this instance.</returns>
+		public Int16 AsInt16()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Int16>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Int16>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)Int16.MinValue;
+					const long maxValue = (long)Int16.MaxValue;
+					
+					long asInt64 = unchecked((long)this._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<Int16>(this);
+					}
+
+					return unchecked((Int16)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Int16.MaxValue);
+					if(maxValue < this._value)
+					{
+						ThrowInvalidTypeAs<Int16>(this);
+					}
+					
+					return (Int16)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Int16)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Int16)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Int16>(this);
+				return default(Int16); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="UInt16" /> instance.
+		/// </summary>
+		/// <returns><see cref="UInt16" /> instance corresponds to this instance.</returns>
+		[CLSCompliant(false)]
+		public UInt16 AsUInt16()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<UInt16>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<UInt16>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				const ulong maxValue = unchecked((ulong)UInt16.MaxValue);
+				
+				if (maxValue < this._value)
+				{
+					// Overflow or negative.
+					ThrowInvalidTypeAs<UInt16>(this);
+				}
+
+				return unchecked((UInt16 )this._value);
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (UInt16)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (UInt16)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<UInt16>(this);
+				return default(UInt16); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Int32" /> instance.
+		/// </summary>
+		/// <returns><see cref="Int32" /> instance corresponds to this instance.</returns>
+		public Int32 AsInt32()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Int32>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Int32>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)Int32.MinValue;
+					const long maxValue = (long)Int32.MaxValue;
+					
+					long asInt64 = unchecked((long)this._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<Int32>(this);
+					}
+
+					return unchecked((Int32)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Int32.MaxValue);
+					if(maxValue < this._value)
+					{
+						ThrowInvalidTypeAs<Int32>(this);
+					}
+					
+					return (Int32)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Int32)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Int32)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Int32>(this);
+				return default(Int32); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="UInt32" /> instance.
+		/// </summary>
+		/// <returns><see cref="UInt32" /> instance corresponds to this instance.</returns>
+		[CLSCompliant(false)]
+		public UInt32 AsUInt32()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<UInt32>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<UInt32>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				const ulong maxValue = unchecked((ulong)UInt32.MaxValue);
+				
+				if (maxValue < this._value)
+				{
+					// Overflow or negative.
+					ThrowInvalidTypeAs<UInt32>(this);
+				}
+
+				return unchecked((UInt32 )this._value);
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (UInt32)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (UInt32)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<UInt32>(this);
+				return default(UInt32); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Int64" /> instance.
+		/// </summary>
+		/// <returns><see cref="Int64" /> instance corresponds to this instance.</returns>
+		public Int64 AsInt64()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Int64>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Int64>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return unchecked((long)this._value);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Int64.MaxValue);
+					if(maxValue < this._value)
+					{
+						ThrowInvalidTypeAs<Int64>(this);
+					}
+					
+					return (Int64)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Int64)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Int64)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Int64>(this);
+				return default(Int64); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="UInt64" /> instance.
+		/// </summary>
+		/// <returns><see cref="UInt64" /> instance corresponds to this instance.</returns>
+		[CLSCompliant(false)]
+		public UInt64 AsUInt64()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<UInt64>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<UInt64>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					if (Int64.MaxValue < this._value)
+					{
+						// Negative.
+						ThrowInvalidTypeAs<UInt64>(this);
+					}
+				}
+
+				return this._value;
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (UInt64)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (UInt64)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<UInt64>(this);
+				return default(UInt64); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Single" /> instance.
+		/// </summary>
+		/// <returns><see cref="Single" /> instance corresponds to this instance.</returns>
+		public Single AsSingle()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Single>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<float>(this);
+			}
+			
+			Debug.Assert(typeCode != null);
+
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return (float)(unchecked((long)this._value));
+				}
+				else
+				{
+					return (float)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Single)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Single)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<float>(this);
+				return default(float); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Double" /> instance.
+		/// </summary>
+		/// <returns><see cref="Double" /> instance corresponds to this instance.</returns>
+		public Double AsDouble()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<Double>();
+			}
+			var typeCode = this._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<double>(this);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return (double)(unchecked((long)this._value));
+				}
+				else
+				{
+					return (double)this._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Double)BitConverter.Int64BitsToDouble(unchecked((long)this._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Double)Binary.FromBits(unchecked((int)this._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<double>(this);
+				return default(double); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="String" /> instance.
+		/// </summary>
+		/// <returns><see cref="String" /> instance corresponds to this instance.</returns>
+		public String? AsString()
+		{
+			VerifyUnderlyingRawType<string>(this, null);
+
+			if(this._handleOrTypeCode == null)
+			{
+				// nil
+				return null;
+			}
+
+			var asString = this._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetString();
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Byte" />[] instance.
+		/// </summary>
+		/// <returns><see cref="Byte" />[] instance corresponds to this instance.</returns>
+		public Byte[]? AsBinary()
+		{
+			VerifyUnderlyingRawType<byte[]>(this, null);
+
+			if(this._handleOrTypeCode == null)
+			{
+				// nil
+				return null;
+			}
+
+			var asString = this._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetByteArray();
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="ReadOnlyMemory<byte>" /> instance.
+		/// </summary>
+		/// <returns><see cref="ReadOnlyMemory<byte>" /> instance corresponds to this instance.</returns>
+		public ReadOnlyMemory<byte> AsReadOnlyMemoryOfByte()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<ReadOnlyMemory<byte>>();
+			}
+			VerifyUnderlyingRawType<ReadOnlyMemory<byte>>(this, null);
+
+			var asString = this._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetByteMemory();
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="ReadOnlyMemory<char>" /> instance.
+		/// </summary>
+		/// <returns><see cref="ReadOnlyMemory<char>" /> instance corresponds to this instance.</returns>
+		public ReadOnlyMemory<char> AsReadOnlyMemoryOfChar()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<ReadOnlyMemory<char>>();
+			}
+			VerifyUnderlyingRawType<ReadOnlyMemory<char>>(this, null);
+
+			var asString = this._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetCharMemory();
+		}
+
+#pragma warning disable 0618 // obsolete
+
+		/// <summary>
+		///		Convert this instance to <see cref="MessagePackExtendedTypeObject" /> instance.
+		/// </summary>
+		/// <returns><see cref="MessagePackExtendedTypeObject" /> instance corresponds to this instance.</returns>
+		public MessagePackExtendedTypeObject AsMessagePackExtendedTypeObject()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<MessagePackExtendedTypeObject>();
+			}
+			VerifyUnderlyingType<MessagePackExtendedTypeObject>(this, null);
+
+			return MessagePackExtendedTypeObject.Unpack(unchecked((byte)this._value), (this._handleOrTypeCode as byte[])!);
+		}
+
+#pragma warning restore 0618 // obsolete
+
+		/// <summary>
+		///		Convert this instance to <see cref="ExtensionTypeObject" /> instance.
+		/// </summary>
+		/// <returns><see cref="ExtensionTypeObject" /> instance corresponds to this instance.</returns>
+		public ExtensionTypeObject AsExtensionTypeObject()
+		{
+			if(this.IsNil)
+			{
+				ThrowCannotBeNilAs<ExtensionTypeObject>();
+			}
+			VerifyUnderlyingType<ExtensionTypeObject>(this, null);
+			Debug.Assert(this._handleOrTypeCode != null);
+
+			return new ExtensionTypeObject(new ExtensionType(unchecked((long)this._value)), (ReadOnlySequence<byte>)this._handleOrTypeCode);
+		}
+
+		#endregion -- Primitive Type Conversion Methods --
+
+		#region -- Conversion Operator Overloads --
+
+
+		/// <summary>
+		///		Convert <see cref="Boolean" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Boolean" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Boolean value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Byte" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Byte" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Byte value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="SByte" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="SByte" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(SByte value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Int16" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Int16" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Int16 value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="UInt16" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="UInt16" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(UInt16 value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Int32" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Int32" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Int32 value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="UInt32" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="UInt32" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(UInt32 value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Int64" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Int64" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Int64 value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="UInt64" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="UInt64" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static implicit operator MessagePackObject(UInt64 value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Single" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Single" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Single value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Double" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Double" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Double value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="String" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="String" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(String value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="Byte" />[]instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="Byte" />[] instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(Byte[] value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="ReadOnlyMemory<byte>" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="ReadOnlyMemory<byte>" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(ReadOnlyMemory<byte> value)
+			=> new MessagePackObject(value);
+
+		/// <summary>
+		///		Convert <see cref="ReadOnlyMemory<char>" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="ReadOnlyMemory<char>" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(ReadOnlyMemory<char> value)
+			=> new MessagePackObject(value);
+
+#pragma warning disable 0618 // obsolete
+
+		/// <summary>
+		///		Convert <see cref="MessagePackExtendedTypeObject" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackExtendedTypeObject" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(MessagePackExtendedTypeObject value)
+			=> new MessagePackObject(value);
+
+#pragma warning restore 0618 // obsolete
+
+		/// <summary>
+		///		Convert <see cref="ExtensionTypeObject" />instance to <see cref="MessagePackObject"/> instance.
+		/// </summary>
+		/// <param name="value"><see cref="ExtensionTypeObject" /> instance.</param>
+		/// <returns><see cref="MessagePackObject"/> instance corresponds to <paramref name="value"/>.</returns>
+		public static implicit operator MessagePackObject(ExtensionTypeObject value)
+			=> new MessagePackObject(value);
+
+
+		/// <summary>
+		///		Convert this instance to <see cref="Boolean" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Boolean" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Boolean(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Boolean>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean)
+			{
+				ThrowInvalidTypeAs<bool>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			return value._value != 0;
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Byte" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Byte" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Byte(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Byte>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Byte>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)Byte.MinValue;
+					const long maxValue = (long)Byte.MaxValue;
+					
+					long asInt64 = unchecked((long)value._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<Byte>(value);
+					}
+
+					return unchecked((Byte)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Byte.MaxValue);
+					if(maxValue < value._value)
+					{
+						ThrowInvalidTypeAs<Byte>(value);
+					}
+					
+					return (Byte)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Byte)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Byte)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Byte>(value);
+				return default(Byte); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="SByte" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="SByte" /> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static explicit operator SByte(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<SByte>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<SByte>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)SByte.MinValue;
+					const long maxValue = (long)SByte.MaxValue;
+					
+					long asInt64 = unchecked((long)value._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<SByte>(value);
+					}
+
+					return unchecked((SByte)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)SByte.MaxValue);
+					if(maxValue < value._value)
+					{
+						ThrowInvalidTypeAs<SByte>(value);
+					}
+					
+					return (SByte)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (SByte)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (SByte)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<SByte>(value);
+				return default(SByte); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Int16" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Int16" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Int16(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Int16>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Int16>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)Int16.MinValue;
+					const long maxValue = (long)Int16.MaxValue;
+					
+					long asInt64 = unchecked((long)value._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<Int16>(value);
+					}
+
+					return unchecked((Int16)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Int16.MaxValue);
+					if(maxValue < value._value)
+					{
+						ThrowInvalidTypeAs<Int16>(value);
+					}
+					
+					return (Int16)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Int16)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Int16)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Int16>(value);
+				return default(Int16); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="UInt16" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="UInt16" /> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static explicit operator UInt16(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<UInt16>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<UInt16>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				const ulong maxValue = unchecked((ulong)UInt16.MaxValue);
+				
+				if (maxValue < value._value)
+				{
+					// Overflow or negative.
+					ThrowInvalidTypeAs<UInt16>(value);
+				}
+
+				return unchecked((UInt16 )value._value);
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (UInt16)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (UInt16)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<UInt16>(value);
+				return default(UInt16); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Int32" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Int32" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Int32(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Int32>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Int32>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					const long minValue = (long)Int32.MinValue;
+					const long maxValue = (long)Int32.MaxValue;
+					
+					long asInt64 = unchecked((long)value._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<Int32>(value);
+					}
+
+					return unchecked((Int32)asInt64);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Int32.MaxValue);
+					if(maxValue < value._value)
+					{
+						ThrowInvalidTypeAs<Int32>(value);
+					}
+					
+					return (Int32)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Int32)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Int32)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Int32>(value);
+				return default(Int32); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="UInt32" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="UInt32" /> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static explicit operator UInt32(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<UInt32>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<UInt32>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				const ulong maxValue = unchecked((ulong)UInt32.MaxValue);
+				
+				if (maxValue < value._value)
+				{
+					// Overflow or negative.
+					ThrowInvalidTypeAs<UInt32>(value);
+				}
+
+				return unchecked((UInt32 )value._value);
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (UInt32)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (UInt32)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<UInt32>(value);
+				return default(UInt32); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Int64" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Int64" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Int64(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Int64>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<Int64>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return unchecked((long)value._value);
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)Int64.MaxValue);
+					if(maxValue < value._value)
+					{
+						ThrowInvalidTypeAs<Int64>(value);
+					}
+					
+					return (Int64)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Int64)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Int64)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<Int64>(value);
+				return default(Int64); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="UInt64" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="UInt64" /> instance corresponds to <paramref name="value"/>.</returns>
+		[CLSCompliant(false)]
+		public static explicit operator UInt64(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<UInt64>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<UInt64>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					if (Int64.MaxValue < value._value)
+					{
+						// Negative.
+						ThrowInvalidTypeAs<UInt64>(value);
+					}
+				}
+
+				return value._value;
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (UInt64)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (UInt64)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<UInt64>(value);
+				return default(UInt64); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Single" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Single" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Single(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Single>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<float>(value);
+			}
+			
+			Debug.Assert(typeCode != null);
+
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return (float)(unchecked((long)value._value));
+				}
+				else
+				{
+					return (float)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Single)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Single)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<float>(value);
+				return default(float); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Double" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Double" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Double(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<Double>();
+			}
+			var typeCode = value._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<double>(value);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return (double)(unchecked((long)value._value));
+				}
+				else
+				{
+					return (double)value._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (Double)BitConverter.Int64BitsToDouble(unchecked((long)value._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (Double)Binary.FromBits(unchecked((int)value._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<double>(value);
+				return default(double); // Never reaches
+			}
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="String" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="String" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator String?(MessagePackObject value)
+		{
+			VerifyUnderlyingRawType<string>(value, "value");
+
+			if(value._handleOrTypeCode == null)
+			{
+				// nil
+				return null;
+			}
+
+			var asString = value._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetString();
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="Byte" />[] instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="Byte" />[] instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator Byte[]?(MessagePackObject value)
+		{
+			VerifyUnderlyingRawType<byte[]>(value, "value");
+
+			if(value._handleOrTypeCode == null)
+			{
+				// nil
+				return null;
+			}
+
+			var asString = value._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetByteArray();
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="ReadOnlyMemory<byte>" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="ReadOnlyMemory<byte>" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator ReadOnlyMemory<byte>(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<ReadOnlyMemory<byte>>();
+			}
+			VerifyUnderlyingRawType<ReadOnlyMemory<byte>>(value, "value");
+
+			var asString = value._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetByteMemory();
+		}
+
+		/// <summary>
+		///		Convert this instance to <see cref="ReadOnlyMemory<char>" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="ReadOnlyMemory<char>" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator ReadOnlyMemory<char>(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<ReadOnlyMemory<char>>();
+			}
+			VerifyUnderlyingRawType<ReadOnlyMemory<char>>(value, "value");
+
+			var asString = value._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetCharMemory();
+		}
+
+#pragma warning disable 0618 // obsolete
+
+		/// <summary>
+		///		Convert this instance to <see cref="MessagePackExtendedTypeObject" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="MessagePackExtendedTypeObject" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator MessagePackExtendedTypeObject(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<MessagePackExtendedTypeObject>();
+			}
+			VerifyUnderlyingType<MessagePackExtendedTypeObject>(value, "value");
+
+			return MessagePackExtendedTypeObject.Unpack(unchecked((byte)value._value), (value._handleOrTypeCode as byte[])!);
+		}
+
+#pragma warning restore 0618 // obsolete
+
+		/// <summary>
+		///		Convert this instance to <see cref="ExtensionTypeObject" /> instance.
+		/// </summary>
+		/// <param name="value"><see cref="MessagePackObject"/> instance.</param>
+		/// <returns><see cref="ExtensionTypeObject" /> instance corresponds to <paramref name="value"/>.</returns>
+		public static explicit operator ExtensionTypeObject(MessagePackObject value)
+		{
+			if(value.IsNil)
+			{
+				ThrowCannotBeNilAs<ExtensionTypeObject>();
+			}
+			VerifyUnderlyingType<ExtensionTypeObject>(value, "value");
+			Debug.Assert(value._handleOrTypeCode != null);
+
+			return new ExtensionTypeObject(new ExtensionType(unchecked((long)value._value)), (ReadOnlySequence<byte>)value._handleOrTypeCode);
+		}
+
+		#endregion -- Conversion Operator Overloads --
+	}
+}
diff --git a/src/MsgPack.Abstraction/MessagePackObject.tt b/src/MsgPack.Abstraction/MessagePackObject.tt
new file mode 100644
index 000000000..399a58025
--- /dev/null
+++ b/src/MsgPack.Abstraction/MessagePackObject.tt
@@ -0,0 +1,723 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<#@ assembly Name="System.Core" #>
+<#@ import namespace="System" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.IO" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+#nullable enable
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+<#
+var typeName = "MessagePackObject";
+var types = 
+	new Dictionary<object, bool> // value: isStringOrBinary
+	{
+		{ typeof(bool),						false },
+		{ typeof(byte),						false },
+		{ typeof(sbyte),					false },
+		{ typeof(short),					false },
+		{ typeof(ushort),					false },
+		{ typeof(int),						false },
+		{ typeof(uint),						false },
+		{ typeof(long),						false },
+		{ typeof(ulong),					false },
+		{ typeof(float),					false },
+		{ typeof(double),					false },
+		{ typeof(string),					true },
+		{ typeof(byte[]),					true },
+		{ "ReadOnlyMemory<byte>",			true },
+		{ "ReadOnlyMemory<char>",			true },
+		{ "MessagePackExtendedTypeObject",	false },
+		{ "ExtensionTypeObject",			false },
+	};
+Func<object, bool> IsNotCLSCompliant =
+	input => 		
+	{
+		var type = (input as Type) ?? typeof(object);
+		return 
+			type == typeof(sbyte)
+			|| type == typeof(ushort)
+			|| type == typeof(uint)
+			|| type == typeof(ulong);
+	};
+#>
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace MsgPack
+{
+	/// <summary>
+	///		Represents deserialized object of MsgPack.
+	/// </summary>
+	[StructLayout(LayoutKind.Auto)]
+	public partial struct <#= typeName #> : IEquatable<<#= typeName #>>
+	{
+		#region -- Constructors --
+<#
+foreach (var type in types)
+{
+	var t = type.Key;
+	var isBinary = type.Value;
+
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning disable 0618 // obsolete
+<#
+	}
+
+	if (isBinary)
+	{
+#>
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <remarks>
+		///		This constructor invokes <see cref="<#= typeName #>(Byte[],Boolean)" /> with <c>false</c>, that means if you pass tha bytes array which is valid utf-8, resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public <#= typeName #>(<#= GetTypeName(t) #> value)
+			: this(value, false) { }
+
+		/// <summary>
+		///		Initializes a new instance of the <see cref="Byte"/>[] type which wraps <see cref="Byte" />[] instance with specified manner.
+		/// </summary>
+		/// <param name="value">A bytes array to be wrapped.</param>
+		/// <param name="isBinary"><c>true</c> if <paramref name="value"/> always should be binary; <c>false</c>, otherwise.</param>
+		/// <remarks>
+		///		When the <paramref name="isBinary" /> is <c>true</c>, then resulting object represents binary even if the <paramref name="value"/> is valid utf-8 sequence,
+		///		that is, its <see cref="UnderlyingType" /> should be <see cref="Byte" />[].
+		///		On the other hand, when  contrast, the <paramref name="isBinary" /> is <c>false</c>, and if the <paramref name="value"/> is valid utf-8, 
+		///		then the resulting object can be <see cref="String" />,
+		///		and its <see cref="UnderlyingType" /> should be <see cref="String" />.
+		/// </remarks>
+		public <#= typeName #>(<#= GetTypeName(t) #> value, bool isBinary)
+<#
+	}
+	else
+	{
+#>
+		/// <summary>
+		///		Initializes a new instance of the <see cref="<#= typeName #>"/> type which wraps <see cref="<#= GetTypeName( t ) #>"/> instance.
+		/// </summary>
+		/// <param name="value">A <see cref="<#= typeName #>"/> value to be wrapped.</param>
+<#
+		if (IsNotCLSCompliant(t))
+		{
+#>
+		[CLSCompliant(false)]
+<#
+		}
+#>
+		public <#= typeName #>(<#= GetTypeName(t) #> value)
+<#
+	}
+#>
+		{
+<#
+	if (t.ToString() == typeof(byte[]).ToString())
+	{
+#>
+			// trick: Avoid long boilerplate initialization.
+			this = new MessagePackObject();
+			if (value == null)
+			{
+				this._handleOrTypeCode = null;
+			}
+			else
+			{
+				this._handleOrTypeCode = new MessagePackString(value, isBinary);
+			}
+<#
+	}
+	else
+	{
+		this.GenerateConstructor(typeName, "this", t);
+	}
+#>
+		}
+<#
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning restore 0618 // obsolete
+<#
+	}
+}
+#>
+
+		#endregion -- Constructors --
+
+		#region -- Primitive Type Conversion Methods --
+<#
+foreach(var t in types.Keys )
+{
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning disable 0618 // obsolete
+<#
+	}
+#>
+
+		/// <summary>
+		///		Convert this instance to <#= t.ToString() == typeof( byte[] ).ToString() ? "<see cref=\"Byte\" />[]" : "<see cref=\"" + GetTypeName( t ) + "\" />" #> instance.
+		/// </summary>
+		/// <returns><#= t.ToString() == typeof( byte[] ).ToString() ? "<see cref=\"Byte\" />[]" : "<see cref=\"" + GetTypeName( t ) + "\" />" #> instance corresponds to this instance.</returns>
+<#
+if (IsNotCLSCompliant(t))
+{
+#>
+		[CLSCompliant(false)]
+<#
+}
+
+var methodName =
+	t == typeof(byte[]) ?
+	"Binary" :
+	t == "ReadOnlyMemory<char>" ?
+	"ReadOnlyMemoryOfChar" :
+	t == "ReadOnlyMemory<byte>" ?
+	"ReadOnlyMemoryOfByte" :
+	GetTypeName(t);
+#>
+		public <#= GetTypeName(t) #><#= GetNullability(t) #> As<#= methodName #>()
+		{
+<#
+	this.GenerateAsT("this", t, false);
+#>
+		}
+<#
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning restore 0618 // obsolete
+<#
+	}
+
+}
+#>
+
+		#endregion -- Primitive Type Conversion Methods --
+
+		#region -- Conversion Operator Overloads --
+
+<#
+foreach (var t in types.Keys)
+{
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning disable 0618 // obsolete
+<#
+	}
+#>
+
+		/// <summary>
+		///		Convert <#= t.ToString() == typeof(byte[]).ToString() ? "<see cref=\"Byte\" />[]" : "<see cref=\"" + GetTypeName(t) + "\" />" #>instance to <see cref="<#= typeName #>"/> instance.
+		/// </summary>
+		/// <param name="value"><#= t.ToString() == typeof(byte[]).ToString() ? "<see cref=\"Byte\" />[]" : "<see cref=\"" + GetTypeName(t) + "\" />" #> instance.</param>
+		/// <returns><see cref="<#=  typeName #>"/> instance corresponds to <paramref name="value"/>.</returns>
+<#
+if (IsNotCLSCompliant(t))
+{
+#>
+		[CLSCompliant(false)]
+<#
+}
+#>
+		public static implicit operator <#= typeName #>(<#= GetTypeName(t) #> value)
+			=> new <#= typeName #>(value);
+<#
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning restore 0618 // obsolete
+<#
+	}
+}
+#>
+
+<#
+foreach (var t in types.Keys)
+{
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning disable 0618 // obsolete
+<#
+	}
+#>
+
+		/// <summary>
+		///		Convert this instance to <#= t.ToString() == typeof(byte[]).ToString() ? "<see cref=\"Byte\" />[]" : "<see cref=\"" + GetTypeName(t) + "\" />" #> instance.
+		/// </summary>
+		/// <param name="value"><see cref="<#= typeName #>"/> instance.</param>
+		/// <returns><#= t.ToString() == typeof(byte[]).ToString() ? "<see cref=\"Byte\" />[]" : "<see cref=\"" + GetTypeName(t) + "\" />" #> instance corresponds to <paramref name="value"/>.</returns>
+<#
+	if (IsNotCLSCompliant(t))
+	{
+#>
+		[CLSCompliant(false)]
+<#
+	}
+#>
+		public static explicit operator <#= GetTypeName(t) #><#= GetNullability(t) #>(<#= typeName #> value)
+		{
+<#
+	this.GenerateAsT("value", t, true);
+#>
+		}
+<#
+	if (t == "MessagePackExtendedTypeObject")
+	{
+#>
+
+#pragma warning restore 0618 // obsolete
+<#
+	}
+
+}
+#>
+
+		#endregion -- Conversion Operator Overloads --
+	}
+}
+<#+
+private static bool IsExplicitConversionRequired(Type type)
+{
+	return 
+		type == typeof(sbyte)
+		|| type == typeof(short)
+		|| type == typeof(int)
+		|| type == typeof(long);
+}
+
+private void GenerateConstructor(string typeName, string val, object typeOrTypeName)
+{
+	var t = typeOrTypeName as Type;
+	var targetTypeName = GetTypeName(typeOrTypeName);
+#>
+			// trick: Avoid long boilerplate initialization.
+			<#= val #> = new <#= typeName #>();
+<#+ 
+	if (targetTypeName == "MessagePackExtendedTypeObject")
+	{
+#>
+			<#= val #>._value = value.TypeCode;
+			<#= val #>._handleOrTypeCode = value.Body;
+<#+
+		return;
+	}
+	else if (targetTypeName == "ExtensionTypeObject")
+	{
+#>
+			<#= val #>._value = unchecked((ulong)value.Type.Tag);
+			<#= val #>._handleOrTypeCode = value.Body;
+<#+
+		return;
+	}
+	else if (t == typeof(byte[]))
+	{
+		// Only implicit conversion operator
+#>
+			if (value == null)
+			{
+				<#= val #>._handleOrTypeCode = null;
+			}
+			else
+			{
+				<#= val #>._handleOrTypeCode = new MessagePackString(value, false);
+			}
+<#+
+		return;
+	}
+	else if (t == typeof(string))
+	{
+#>
+			if (value == null)
+			{
+				<#= val #>._handleOrTypeCode = null;
+			}
+			else
+			{
+				<#= val #>._handleOrTypeCode = new MessagePackString(value);
+			}
+<#+
+		return;
+	}
+	else if (targetTypeName.EndsWith("<byte>"))
+	{
+		// Only implicit conversion operator
+#>
+			<#= val #>._handleOrTypeCode = new MessagePackString(value, false);
+<#+
+		return;
+	}
+	else if (targetTypeName.EndsWith("<char>"))
+	{
+#>
+			<#= val #>._handleOrTypeCode = new MessagePackString(value);
+<#+
+		return;
+	}
+	
+	if (t == typeof(bool))
+	{
+#>
+			<#= val #>._value = value ? (ulong)1 : 0;
+<#+ 
+	}
+	else if (IsExplicitConversionRequired(t))
+	{
+#>
+			<#= val #>._value = unchecked((ulong)value);
+<#+ 
+	}
+	else if (t == typeof(float))
+	{
+#>
+			<#= val #>._value = unchecked((ulong)Binary.ToBits(value));
+<#+ 
+	}
+	else if (t == typeof(double))
+	{
+#>
+			<#= val #>._value = unchecked((ulong)BitConverter.DoubleToInt64Bits(value));
+<#+ 
+	}
+	else
+	{
+#>
+			<#= val #>._value = value;
+<#+ 
+	}
+
+#>
+			<#= val #>._handleOrTypeCode = <#= t.Name #>TypeCode;
+<#+
+} // GenerateConstructor
+
+private void GenerateAsT(string val, Object typeOrTypeName, bool passParameterName)
+{
+	var t = typeOrTypeName as Type;
+	var typeName = GetTypeName(typeOrTypeName);
+
+	if(t == null || t.IsValueType)
+	{
+#>
+			if(<#= val #>.IsNil)
+			{
+				ThrowCannotBeNilAs<#= "<" + typeName  + ">" #>();
+			}
+<#+
+	}
+
+	if (typeName == "MessagePackExtendedTypeObject")
+	{
+#>
+			VerifyUnderlyingType<MessagePackExtendedTypeObject>(<#= val #>, <#= passParameterName ? "\"" + val + "\"" : "null" #>);
+
+			return MessagePackExtendedTypeObject.Unpack(unchecked((byte)<#= val #>._value), (<#= val #>._handleOrTypeCode as byte[])!);
+<#+
+	}
+	else if (typeName == "ExtensionTypeObject")
+	{
+#>
+			VerifyUnderlyingType<ExtensionTypeObject>(<#= val #>, <#= passParameterName ? "\"" + val + "\"" : "null" #>);
+			Debug.Assert(<#= val #>._handleOrTypeCode != null);
+
+			return new ExtensionTypeObject(new ExtensionType(unchecked((long)<#= val #>._value)), (ReadOnlySequence<byte>)<#= val #>._handleOrTypeCode);
+<#+
+	}
+	else if (t == typeof(byte[]))
+	{
+#>
+			VerifyUnderlyingRawType<byte[]>(<#= val #>, <#= passParameterName ? "\"" + val + "\"" : "null" #>);
+
+			if(<#= val #>._handleOrTypeCode == null)
+			{
+				// nil
+				return null;
+			}
+
+			var asString = <#= val #>._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetByteArray();
+<#+
+	}
+	else if (t == typeof(string))
+	{
+#>
+			VerifyUnderlyingRawType<string>(<#= val #>, <#= passParameterName ? "\"" + val + "\"" : "null" #>);
+
+			if(<#= val #>._handleOrTypeCode == null)
+			{
+				// nil
+				return null;
+			}
+
+			var asString = <#= val #>._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetString();
+<#+
+	}
+	else if (typeName.EndsWith("<byte>"))
+	{
+#>
+			VerifyUnderlyingRawType<ReadOnlyMemory<byte>>(<#= val #>, <#= passParameterName ? "\"" + val + "\"" : "null" #>);
+
+			var asString = <#= val #>._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetByteMemory();
+<#+
+	}
+	else if (typeName.EndsWith("<char>"))
+	{
+#>
+			VerifyUnderlyingRawType<ReadOnlyMemory<char>>(<#= val #>, <#= passParameterName ? "\"" + val + "\"" : "null" #>);
+
+			var asString = <#= val #>._handleOrTypeCode as MessagePackString;
+			Debug.Assert(asString != null);
+			return asString.GetCharMemory();
+<#+
+	}
+	else if (t == typeof(bool))
+	{
+#>
+			var typeCode = <#= val #>._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null || typeCode.TypeCode != MessagePackValueTypeCode.Boolean)
+			{
+				ThrowInvalidTypeAs<bool>(<#= val #>);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			return <#= val #>._value != 0;
+<#+
+	}
+	else if (t == typeof(float))
+	{
+#>
+			var typeCode = <#= val #>._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<float>(<#= val #>);
+			}
+			
+			Debug.Assert(typeCode != null);
+
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return (float)(unchecked((long)<#= val #>._value));
+				}
+				else
+				{
+					return (float)<#= val #>._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (<#= t.Name #>)BitConverter.Int64BitsToDouble(unchecked((long)<#= val #>._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (<#= t.Name #>)Binary.FromBits(unchecked((int)<#= val #>._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<float>(<#= val #>);
+				return default(float); // Never reaches
+			}
+<#+
+	}
+	else if (t == typeof(double))
+	{
+#>
+			var typeCode = <#= val #>._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<double>(<#= val #>);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+					return (double)(unchecked((long)<#= val #>._value));
+				}
+				else
+				{
+					return (double)<#= val #>._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (<#= t.Name #>)BitConverter.Int64BitsToDouble(unchecked((long)<#= val #>._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (<#= t.Name #>)Binary.FromBits(unchecked((int)<#= val #>._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<double>(<#= val #>);
+				return default(double); // Never reaches
+			}
+<#+
+	}
+	else if (t.Name[0] == 'U')
+	{
+#>
+			var typeCode = <#= val #>._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+<#+
+		if (t == typeof(UInt64))
+		{
+#>
+				if (typeCode.IsSigned)
+				{
+					if (Int64.MaxValue < <#= val #>._value)
+					{
+						// Negative.
+						ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+					}
+				}
+
+				return <#= val #>._value;
+<#+
+		}
+		else
+		{
+#>
+				const ulong maxValue = unchecked((ulong)<#= t.Name #>.MaxValue);
+				
+				if (maxValue < <#= val #>._value)
+				{
+					// Overflow or negative.
+					ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+				}
+
+				return unchecked((<#= t.Name #> )<#= val #>._value);
+<#+
+		}
+#>
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (<#= t.Name #>)BitConverter.Int64BitsToDouble(unchecked((long)<#= val #>._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (<#= t.Name #>)Binary.FromBits(unchecked((int)<#= val #>._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+				return default(<#= t.Name #>); // Never reaches
+			}
+<#+
+	}
+	else
+	{
+#>
+			var typeCode = <#= val #>._handleOrTypeCode as ValueTypeCode;
+			if (typeCode == null)
+			{
+				ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+			}
+
+			Debug.Assert(typeCode != null);
+			
+			if (typeCode.IsInteger)
+			{
+				if (typeCode.IsSigned)
+				{
+<#+
+		if (t == typeof(Int64) )
+		{
+#>
+					return unchecked((long)<#= val #>._value);
+<#+
+		}
+		else
+		{
+#>
+					const long minValue = (long)<#= t.Name #>.MinValue;
+					const long maxValue = (long)<#= t.Name #>.MaxValue;
+					
+					long asInt64 = unchecked((long)<#= val #>._value);
+					if(asInt64 < minValue || maxValue < asInt64)
+					{
+						ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+					}
+
+					return unchecked((<#= t.Name #>)asInt64);
+<#+
+		}
+#>
+				}
+				else
+				{
+					const ulong maxValue = unchecked((ulong)<#= t.Name #>.MaxValue);
+					if(maxValue < <#= val #>._value)
+					{
+						ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+					}
+					
+					return (<#= t.Name #>)<#= val #>._value;
+				}
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Double)
+			{
+				return (<#= t.Name #>)BitConverter.Int64BitsToDouble(unchecked((long)<#= val #>._value));
+			}
+			else if (typeCode.TypeCode == MessagePackValueTypeCode.Single)
+			{
+				return (<#= t.Name #>)Binary.FromBits(unchecked((int)<#= val #>._value));
+			}
+			else
+			{
+				ThrowInvalidTypeAs<#= "<" + t.Name + ">" #>(<#= val #>);
+				return default(<#= t.Name #>); // Never reaches
+			}
+<#+
+	}
+}
+
+private static string GetTypeName(object typeOrTypeName)
+	=> (typeOrTypeName as string) ?? (typeOrTypeName as Type).Name;
+
+private static string GetNullability(object typeOrTypeName)
+	=> (typeOrTypeName == typeof(byte[]) || typeOrTypeName == typeof(string)) ? "?" : String.Empty;
+#>
diff --git a/src/MsgPack/MessagePackObjectDictionary.cs b/src/MsgPack/MessagePackObjectDictionary.cs
index 3dec8140f..e18f81bc2 100644
--- a/src/MsgPack/MessagePackObjectDictionary.cs
+++ b/src/MsgPack/MessagePackObjectDictionary.cs
@@ -450,7 +450,7 @@ private static MessagePackObject ValidateObjectArgument(object? obj, [CallerArgu
 				}
 				case TypeCode.String:
 				{
-					return value.ToString();
+					return value.ToString() ?? String.Empty;
 				}
 				case TypeCode.UInt16:
 				{

From 7e29b151f26003d2a33aebd295464912ca656266 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 23:00:47 +0900
Subject: [PATCH 81/82] FIX position repoting basics

---
 src/MsgPack/MessageTypeException.cs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/MsgPack/MessageTypeException.cs b/src/MsgPack/MessageTypeException.cs
index 7707b26f7..b60a5d279 100644
--- a/src/MsgPack/MessageTypeException.cs
+++ b/src/MsgPack/MessageTypeException.cs
@@ -21,8 +21,6 @@ public class MessageTypeException : DecodeException
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with the default error message.
 		/// </summary>
-		[Obsolete("Use .ctor(long) instead.")]
-		[EditorBrowsable(EditorBrowsableState.Never)]
 		public MessageTypeException() : this(null) { }
 
 		public MessageTypeException(long position) : this(position, null) { }
@@ -31,8 +29,6 @@ public MessageTypeException(long position) : this(position, null) { }
 		///		Initializes a new instance of the <see cref="MessageTypeException"/> class with a specified error message.
 		/// </summary>
 		/// <param name="message">The message that describes the error. </param>
-		[Obsolete("Use .ctor(long, string?) instead.")]
-		[EditorBrowsable(EditorBrowsableState.Never)]
 		public MessageTypeException(string? message) : this(message, null) { }
 
 		public MessageTypeException(long position, string? message) : this(position, message, null) { }
@@ -44,8 +40,6 @@ public MessageTypeException(long position, string? message) : this(position, mes
 		/// <param name="inner">
 		///		The exception that is the cause of the current exception, or a <c>null</c> if no inner exception is specified.
 		/// </param>
-		[Obsolete("Use .ctor(long, string?, Exception?) instead.")]
-		[EditorBrowsable(EditorBrowsableState.Never)]
 		public MessageTypeException(string? message, Exception? inner) : this(0, message ?? "Invalid message type.", inner) { }
 
 		public MessageTypeException(long position, string? message, Exception? innerException)

From 88118a9be7da672d7be05cdff2c97e1d32806767 Mon Sep 17 00:00:00 2001
From: yfakariya <yfakariya@gmail.com>
Date: Wed, 7 Oct 2020 23:02:35 +0900
Subject: [PATCH 82/82] WIP: Implement serializer layer

---
 .../Serialization/DeserializationOptions.cs   |   41 -
 .../DeserializationOptionsBuilder.cs          |   54 -
 .../ObjectSerializationContext.cs             |   23 -
 .../Serialization/SerializationOptions.cs     |   47 -
 .../SerializationOptionsBuilder.cs            |   29 -
 .../ArrayDelegateSerializer.cs                |   10 +-
 .../CollectionDelegateSerializer.cs           |   10 +-
 .../DictionaryDelegateSerializer.cs           |   17 +-
 .../ObjectDelegateSerializer.cs               |   51 +-
 .../ReflectionSerializerBuilder.cs            |    6 +-
 .../ReflectionSerializer`1.cs                 |   20 +-
 .../MsgPack.Serialization.csproj              |  119 +-
 .../Properties/AssemblyInfo.cs                |    3 +
 .../Serialization/AotHelper.cs                |   52 +
 ...lizationOperationContext.StreamSequence.cs |    2 +-
 .../AsyncDeserializationOperationContext.cs   |    2 +-
 .../AsyncDeserializationOperationContext.tt   |    0
 .../AsyncSerializationOperationContext.cs     |    2 +-
 .../AsyncSerializationOperationContext.tt     |    0
 .../Serialization/BindingOptionsBuilder.cs    |  100 ++
 .../BoxedDateTimeConversionMethod.cs          |   85 ++
 .../BoxedEnumSerializationMethod.cs           |   49 +
 .../DateTimeObjectSerializer.cs               |  225 +++
 .../DateTimeOffsetObjectSerializer.cs         |  329 +++++
 .../EnumSerializerProvider.cs                 |  133 ++
 .../BuiltinSerializers/EnumSerializer`1.cs    |  211 +++
 .../BuiltinSerializers/EnumSerializers.cs     | 1251 +++++++++++++++++
 .../BuiltinSerializers/EnumSerializers.tt     |  334 +++++
 .../FileTimeObjectSerializer.cs               |  265 ++++
 .../InternalDateTimeExtensions.cs             |   38 +
 .../TimestampObjectSerializer.cs              |  256 ++++
 .../CompatibilityAdapterAttribute.cs          |   48 +
 .../Serialization/CompatibilityAdapterKind.cs |   33 +
 .../DateTimeSerializationOptionsBuilder.cs    |  204 +++
 .../DateTimeSerializerProvider.cs             |  160 +++
 .../DefaultConcreteTypeRepositoryBuilder.cs   |  216 +++
 ...sagePackAttributeCompatibilityProviders.cs |  111 ++
 .../Serialization/DefaultSerializer`1.cs      |   25 +
 .../DeserializationOperationContext.cs        |    2 +-
 .../DeserializationOperationContext.tt        |    0
 .../Serialization/DeserializationOptions.cs   |   90 ++
 .../DeserializationOptionsBuilder.cs          |  278 ++++
 .../Serialization/Dianostic.cs                |  163 +++
 .../Serialization/Dianostic.tt                |  140 ++
 .../DictionarySerializationOptionsBuilder.cs  |  110 ++
 .../Serialization/DynamicEnumSerializer`1.cs  |   51 +
 .../EnumSerializationOptionsBuilder.cs        |  193 +++
 .../Serialization/IBindingOptions.cs          |   46 +
 .../IDateTimeSerializationOptions.cs          |   61 +
 .../IDefaultConcreteTypeRepository.cs         |   76 +
 .../IDictionarySerializationOptions.cs        |   45 +
 .../IEnumSerializationOptions.cs              |   47 +
 .../IObjectSerializerProvider.cs              |   24 +
 .../ISerializationCompatibilityOptions.cs     |  119 ++
 .../ISerializerGenerationOptions.cs           |  111 ++
 .../Serialization/ImmutableBindingOptions.cs  |   36 +
 .../ImmutableDateTimeSerializationOptions.cs  |  110 ++
 .../ImmutableDefaultConcreteTypeRepository.cs |   45 +
 ...ImmutableDictionarySerializationOptions.cs |   35 +
 .../ImmutableEnumSerializationOptions.cs      |   35 +
 ...utableSerializationCompatibilityOptions.cs |   55 +
 .../ImmutableSerializerGenerationOptions.cs   |  101 ++
 .../LazyDelegatingObjectSerializer`1.cs       |   86 ++
 .../Serialization/MemberAccessStrategy.cs     |   55 +
 .../MessagePackIgnoreAttributeData.cs         |   14 +
 .../MessagePackMemberAttributeData.cs         |   73 +
 ...MessagePackSerializationMethodAttribute.cs |   55 +
 .../NaiveConcurrentFifoCache`2.cs             |   78 +
 .../Serialization/NameTransformation.cs       |  101 ++
 .../NonCollectionObjectSerializer`1.cs        |   39 +
 .../NullableObjectSerializer`1.cs             |   89 ++
 .../ObjectSerializationContext.cs             |  265 ++++
 .../Serialization/ObjectSerializer.cs         |   16 +-
 .../Serialization/ObjectSerializer`1.cs       |   12 +-
 .../Serialization/OperationContext.ttinclude  |    0
 .../KnownTypePolymorphicObjectSerializer`1.cs |  138 ++
 .../PolymorphicSerializerProvider.cs          |   47 +
 ...peEmbedingPolymorphicObjectSerializer`1.cs |   87 ++
 .../ResolveObjectSerializerEventArgs.cs       |   33 +
 .../ResolveObjectSerializerEventHandler.cs    |   14 +
 ...erializationCompatibilityOptionsBuilder.cs |  215 +++
 .../SerializationOperationContext.cs          |    2 +-
 .../SerializationOperationContext.tt          |    0
 .../Serialization/SerializationOptions.cs     |   87 ++
 .../SerializationOptionsBuilder.cs            |  364 +++++
 .../Serialization/Serializer.cs               |   10 +
 .../Serialization/SerializerBuilder.cs        |   50 +-
 .../Serialization/SerializerFactory.cs        |   96 ++
 .../SerializerGenerationOptions.cs            |   60 -
 .../SerializerGenerationOptionsBuilder.cs     |  352 +++++
 .../Serialization/SerializerProvider.cs       |  405 ++++++
 .../SerializerProviderExtensions.Register.cs  |   70 +
 .../SerializerProviderExtensions.Register.tt  |   81 ++
 .../SerializerProviderExtensions.cs           |  397 ++++++
 .../SerializerProviderExtensions.tt           |   29 +
 .../Serialization/Serializer`1.cs}            |   54 +-
 .../StaticObjectSerializerProvider.cs         |   24 +
 .../Serialization/Throw.Internal.cs           |  207 ++-
 .../Serialization/TypeKeyRepositoryLogics.cs  |   50 +
 .../Serialization/DateTimeConversionMethod.cs |   17 +-
 .../DateTimeMemberConversionMethod.cs         |   15 +-
 .../Serialization/KeyNameTransformers.cs      |   88 +-
 .../MessagePackDateTimeMemberAttribute.cs     |   34 +-
 .../Serialization/MessagePackEnumAttribute.cs |    6 +-
 .../MessagePackEnumMemberAttribute.cs         |    4 +
 .../MessagePackMemberAttribute.cs             |   11 +-
 .../Polymorphic/TypeInfoEncoder.cs            | 1048 ++++++++++----
 .../PolymorphismSchema.Constructors.cs        |  277 ++--
 .../PolymorphismSchema.Internals.cs           |  436 +++---
 .../Serialization/PolymorphismSchema.cs       |  151 +-
 .../PolymorphismSchemaChildrenType.cs         |   22 +-
 .../Serialization/PolymorphismTarget.cs       |   28 +-
 .../Reflection/ReflectionExtensions.cs        |  130 +-
 ...ionExtensions.InvokePreservingExtension.cs |  159 ++-
 .../Serialization/ReflectionExtensions.cs     |   25 +-
 .../Serialization/SerializationTarget.cs      |  763 +++++++---
 .../SerializerRegistrationOptions.cs          |   29 +-
 .../Serialization/SerializingMember.cs        |   14 +-
 .../Serialization/TypeKeyRepository.cs        |  275 ++--
 119 files changed, 11984 insertions(+), 1837 deletions(-)
 delete mode 100644 src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
 delete mode 100644 src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
 delete mode 100644 src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
 delete mode 100644 src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
 delete mode 100644 src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/AotHelper.cs
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs (91%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/AsyncDeserializationOperationContext.cs (96%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/AsyncDeserializationOperationContext.tt (100%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/AsyncSerializationOperationContext.cs (96%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/AsyncSerializationOperationContext.tt (100%)
 create mode 100644 src/MsgPack.Serialization/Serialization/BindingOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BoxedDateTimeConversionMethod.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BoxedEnumSerializationMethod.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeObjectSerializer.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeOffsetObjectSerializer.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializerProvider.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.tt
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/FileTimeObjectSerializer.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/InternalDateTimeExtensions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/BuiltinSerializers/TimestampObjectSerializer.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/CompatibilityAdapterAttribute.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/CompatibilityAdapterKind.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DateTimeSerializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DateTimeSerializerProvider.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DefaultConcreteTypeRepositoryBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DefaultMessagePackAttributeCompatibilityProviders.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DefaultSerializer`1.cs
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/DeserializationOperationContext.cs (96%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/DeserializationOperationContext.tt (100%)
 create mode 100644 src/MsgPack.Serialization/Serialization/DeserializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DeserializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Dianostic.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Dianostic.tt
 create mode 100644 src/MsgPack.Serialization/Serialization/DictionarySerializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/DynamicEnumSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/EnumSerializationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/IBindingOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/IDateTimeSerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/IDefaultConcreteTypeRepository.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/IDictionarySerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/IEnumSerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/IObjectSerializerProvider.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ISerializationCompatibilityOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ISerializerGenerationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableBindingOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableDateTimeSerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableDefaultConcreteTypeRepository.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableDictionarySerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableEnumSerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableSerializationCompatibilityOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ImmutableSerializerGenerationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/LazyDelegatingObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/MemberAccessStrategy.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/MessagePackIgnoreAttributeData.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/MessagePackMemberAttributeData.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/MessagePackSerializationMethodAttribute.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/NaiveConcurrentFifoCache`2.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/NameTransformation.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/NonCollectionObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/NullableObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ObjectSerializationContext.cs
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/ObjectSerializer.cs (73%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/ObjectSerializer`1.cs (85%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/OperationContext.ttinclude (100%)
 create mode 100644 src/MsgPack.Serialization/Serialization/Polymorphic/KnownTypePolymorphicObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Polymorphic/PolymorphicSerializerProvider.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/Polymorphic/TypeEmbedingPolymorphicObjectSerializer`1.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventArgs.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventHandler.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializationCompatibilityOptionsBuilder.cs
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/SerializationOperationContext.cs (95%)
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/SerializationOperationContext.tt (100%)
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializationOptionsBuilder.cs
 rename src/{MsgPack.Abstraction => MsgPack.Serialization}/Serialization/Serializer.cs (65%)
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerFactory.cs
 delete mode 100644 src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerGenerationOptionsBuilder.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerProvider.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.tt
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.tt
 rename src/{MsgPack.Abstraction/Serialization/Serializer`2.cs => MsgPack.Serialization/Serialization/Serializer`1.cs} (74%)
 create mode 100644 src/MsgPack.Serialization/Serialization/StaticObjectSerializerProvider.cs
 create mode 100644 src/MsgPack.Serialization/Serialization/TypeKeyRepositoryLogics.cs

diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
deleted file mode 100644
index 350b97c29..000000000
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptions.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System.Buffers;
-using System.Text;
-
-namespace MsgPack.Serialization
-{
-	public sealed class DeserializationOptions
-	{
-		public static DeserializationOptions Default { get; } = new DeserializationOptionsBuilder().Create();
-
-		public int MaxArrayLength { get; }
-		public int MaxMapCount { get; }
-		public int MaxPropertyKeyLength { get; }
-		public int MaxDepth { get; }
-		public Encoding? StringEncoding { get; }
-		public ArrayPool<byte> ByteBufferPool { get; }
-		public bool ClearsBuffer { get; }
-
-		internal DeserializationOptions(
-			int maxArrayLength,
-			int maxMapCount,
-			int maxPropertyKeyLength,
-			int maxDepth,
-			Encoding? stringEncoding,
-			ArrayPool<byte> arrayPool,
-			bool clearsBuffer
-		)
-		{
-			this.MaxArrayLength =maxArrayLength;
-			this.MaxMapCount = maxMapCount;
-			this.MaxPropertyKeyLength = maxPropertyKeyLength;
-			this.MaxDepth = maxDepth;
-			this.StringEncoding = stringEncoding;
-			this.ByteBufferPool = arrayPool;
-			this.ClearsBuffer = clearsBuffer;
-		}
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
deleted file mode 100644
index a83ea3310..000000000
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOptionsBuilder.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System.Buffers;
-using System.Text;
-using MsgPack.Internal;
-
-namespace MsgPack.Serialization
-{
-	public sealed class DeserializationOptionsBuilder
-	{
-		private int _maxArrayLength = OptionsDefaults.MaxArrayLength;
-
-		public int MaxArrayLength
-		{
-			get => this._maxArrayLength;
-			set => this._maxArrayLength = Ensure.IsBetween(value, 0, OptionsDefaults.MaxMultiByteCollectionLength);
-		}
-
-		private int _maxMapCount = OptionsDefaults.MaxMapCount;
-
-		public int MaxMapCount
-		{
-			get => this._maxMapCount;
-			set => this._maxMapCount = Ensure.IsBetween(value, 0, OptionsDefaults.MaxMultiByteCollectionLength);
-		}
-
-		private int _maxPropertyKeyLength = OptionsDefaults.MaxPropertyKeyLength;
-
-		public int MaxPropertyKeyLength
-		{
-			get => this._maxPropertyKeyLength;
-			set => this._maxPropertyKeyLength = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
-		}
-
-		private int _maxDepth = OptionsDefaults.MaxDepth;
-
-		public int MaxDepth
-		{
-			get => this._maxDepth;
-			set => this._maxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
-		}
-
-		public Encoding? StringEncoding { get; set; }
-
-		public ArrayPool<byte>? ArrayPool { get; set; }
-
-		public bool ClearsBuffer { get; set; } = OptionsDefaults.ClearsBuffer;
-
-		public DeserializationOptions Create()
-			=> new DeserializationOptions(this.MaxArrayLength, this.MaxMapCount, this.MaxPropertyKeyLength, this.MaxDepth, this.StringEncoding, this.ArrayPool ?? ArrayPool<byte>.Shared, this.ClearsBuffer);
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs b/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
deleted file mode 100644
index fe78f0051..000000000
--- a/src/MsgPack.Abstraction/Serialization/ObjectSerializationContext.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-
-namespace MsgPack.Serialization
-{
-	public sealed class ObjectSerializationContext
-	{
-		public SerializationOptions Options { get; }
-
-		public ObjectSerializer<T> GetSerializer<T>(object? providerParameter)
-		{
-			throw new NotImplementedException();
-		}
-
-		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
-		{
-			throw new NotImplementedException();
-		}
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
deleted file mode 100644
index 5aab3b4f2..000000000
--- a/src/MsgPack.Abstraction/Serialization/SerializationOptions.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System.Text;
-
-namespace MsgPack.Serialization
-{
-	public sealed class SerializationOptions
-	{
-		public static SerializationOptions Default { get; } = new SerializationOptionsBuilder().Create();
-
-		public int MaxDepth { get; }
-
-		public Encoding? StringEncoding { get; }
-
-		public SerializationMethod? PreferredSerializationMethod { get; }
-
-		/// <summary>
-		///		Gets or sets a value indicating whether generated and/or reflection serializers should not access non public members via privileged reflection.
-		/// </summary>
-		/// <value>
-		///		<c>true</c> if privileged reflection access is disabled; otherwise, <c>false</c>. Defaults to <c>false</c>.
-		/// </value>
-		/// <remarks>
-		///		The privileged reflection means:
-		///		<list type="bullet">
-		///			<item>Access for non-public fields or property accessors via reflection. This operation requires <c>ReflectionPermission</c> of <c>MemberAccess</c> or <c>RestrictedMemberAccess</c>.</item>
-		///			<item>Writing values for init only fields via reflection. This operation requires <c>SecurityPermission</c> of <c>SerializationFormatter</c>.</item>
-		///		</list>
-		///		If the program run on non-privileged Silverlight environment or restricted desktop CLR,
-		///		serialization and deserialization should fail with <c>SecurityException</c>.
-		/// </remarks>
-		public bool DisablePrivilegedAccess { get; }
-
-
-		internal SerializationOptions(
-			SerializationOptionsBuilder builder
-		)
-		{
-			this.MaxDepth = builder.MaxDepth;
-			this.StringEncoding = builder.StringEncoding;
-			this.PreferredSerializationMethod = builder.PreferredSerializationMethod;
-			this.DisablePrivilegedAccess = builder.DisablePrivilegedAccess;
-		}
-	}
-}
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs b/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
deleted file mode 100644
index 2e9d82986..000000000
--- a/src/MsgPack.Abstraction/Serialization/SerializationOptionsBuilder.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System.Text;
-using MsgPack.Internal;
-
-namespace MsgPack.Serialization
-{
-	public sealed class SerializationOptionsBuilder
-	{
-		private int _maxDepth = OptionsDefaults.MaxDepth;
-
-		public int MaxDepth
-		{
-			get => this._maxDepth;
-			set => this._maxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
-		}
-
-		public Encoding? StringEncoding { get; set; }
-
-		public SerializationMethod? PreferredSerializationMethod { get; set; } = OptionsDefaults.PreferredSerializationMethod;
-
-		public bool DisablePrivilegedAccess { get; set; }
-
-		public SerializationOptions Create()
-			=> new SerializationOptions(this);
-	}
-}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs
index aed418e19..d91a96b66 100644
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ArrayDelegateSerializer.cs
@@ -31,7 +31,8 @@ public ArrayDelegateSerializer(
 			AsyncDeserialization deserializeItemAsync,
 #endif // FEATURE_TAP
 			Type targetType,
-			in CollectionTraits traits
+			in CollectionTraits traits,
+			ISerializerGenerationOptions options
 		)
 		{
 			this._targetType = targetType;
@@ -40,8 +41,11 @@ in CollectionTraits traits
 #if FEATURE_TAP
 			this._deserializeItemAsync = deserializeItemAsync;
 #endif // FEATURE_TAP
-#warning TODO: allowNonCollectionEnumerableTypes
-			this._itemIsCollection = traits.ElementType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+			this._itemIsCollection =
+				traits.ElementType!.GetCollectionTraits(
+					CollectionTraitOptions.None, 
+					allowNonCollectionEnumerableTypes: options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes
+				).CollectionType != CollectionKind.NotCollection;
 		}
 
 		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs
index cf9f6fd32..e0362e4dd 100644
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/CollectionDelegateSerializer.cs
@@ -39,7 +39,8 @@ public CollectionDelegateSerializer(
 			AsyncDeserialization deserializeItemAsync,
 #endif // FEATURE_TAP
 			Type targetType,
-			in CollectionTraits traits
+			in CollectionTraits traits,
+			ISerializerGenerationOptions options
 		)
 		{
 			var countPropertyGetter = traits.CountPropertyGetter!;
@@ -70,8 +71,11 @@ in CollectionTraits traits
 			this._deserializeItemAsync = deserializeItemAsync;
 #endif // FEATURE_TAP
 
-#warning TODO: allowNonCollectionEnumerableTypes
-			this._itemIsCollection = traits.ElementType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+			this._itemIsCollection =
+				traits.ElementType!.GetCollectionTraits(
+					CollectionTraitOptions.None,
+					allowNonCollectionEnumerableTypes: options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes
+				).CollectionType != CollectionKind.NotCollection;
 		}
 
 		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs
index a6ca895d2..2f0d57314 100644
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/DictionaryDelegateSerializer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -46,7 +46,8 @@ public DictionaryDelegateSerializer(
 			AsyncDeserialization deserializeValueAsync,
 #endif // FEATURE_TAP
 			Type targetType,
-			in CollectionTraits traits
+			in CollectionTraits traits,
+			ISerializerGenerationOptions options
 		)
 		{
 			var countPropertyGetter = traits.CountPropertyGetter!;
@@ -89,9 +90,15 @@ in CollectionTraits traits
 			this._deserializeValueAsync = deserializeValueAsync;
 #endif // FEATURE_TAP
 
-#warning TODO: allowNonCollectionEnumerableTypes
-			this._keyIsCollection = keyType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
-			this._valueIsCollection = valueType!.GetCollectionTraits(CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: false).CollectionType != CollectionKind.NotCollection;
+			this._keyIsCollection =
+				keyType!.GetCollectionTraits(
+					CollectionTraitOptions.None, 
+					allowNonCollectionEnumerableTypes: options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes
+				).CollectionType != CollectionKind.NotCollection;
+			this._valueIsCollection =
+				valueType!.GetCollectionTraits(
+					CollectionTraitOptions.None, allowNonCollectionEnumerableTypes: options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes
+				).CollectionType != CollectionKind.NotCollection;
 		}
 
 		public void Serialize(ref SerializationOperationContext context, object? obj, IBufferWriter<byte> sink)
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs
index e812a712d..5918f4645 100644
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ObjectDelegateSerializer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -39,18 +39,18 @@ internal sealed partial class ObjectDelegateSerializer : IReflectionObjectSerial
 		// object
 		// tuple
 		// value tuple
-		public ObjectDelegateSerializer(ObjectSerializationContext context, SerializationTarget target)
+		public ObjectDelegateSerializer(SerializerProvider provider, in SerializationTarget target, ISerializerGenerationOptions options)
 		{
 			this._target = target;
 			var isTuple = TupleItems.IsTuple(target.Type);
 			this._tupleTypes = isTuple ? null : TupleItems.CreateTupleTypeList(target.Type);
-			this._memberValueEncoders = CreateMemberValueEncoders(context, target.Members).ToList();
+			this._memberValueEncoders = CreateMemberValueEncoders(provider, target.Members).ToList();
 			this._memberValueDecoders =
 				CreateMemberValueDecoders(
-					context,
+					provider,
 					target.Members,
 					hasDeserializationConstructor: target.DeserializationConstructor != null,
-					hasPriviledgedAccess: !context.Options.DisablePrivilegedAccess
+					hasPriviledgedAccess: !options.BindingOptions.IsPrivilegedAccessDisabled
 				).ToList();
 			this._memberIsCollections = DetermineWhetherIndividualMembersAreCollection(target.Members).ToList();
 			this._memberValueGetters = CreateMemberValueGetters(target.Members, this._tupleTypes).ToList();
@@ -59,20 +59,22 @@ public ObjectDelegateSerializer(ObjectSerializationContext context, Serializatio
 #if FEATURE_TAP
 			this._asyncMemberValueDecoders =
 				CreateAsyncMemberValueDecoders(
-					context,
+					provider,
 					target.Members,
 					hasDeserializationConstructor: target.DeserializationConstructor != null,
-					hasPriviledgedAccess: !context.Options.DisablePrivilegedAccess
+					hasPriviledgedAccess: !options.BindingOptions.IsPrivilegedAccessDisabled
 				).ToList();
 #endif // FEATURE_TAP
 		}
 
-		private static IEnumerable<Delegate> CreateMemberValueEncoders(ObjectSerializationContext context, IEnumerable<SerializingMember> members)
+		private static IEnumerable<Delegate> CreateMemberValueEncoders(SerializerProvider provider, IEnumerable<SerializingMember> members)
 		{
 			foreach (var member in members)
 			{
 				var type = member.Member.GetMemberValueType();
 				var memberInfo = member.Member;
+				var schema = PolymorphismSchema.Create(type, member);
+
 				yield return
 					type switch
 					{
@@ -100,19 +102,20 @@ var t
 							=> EncodeBinary,
 						var t when t == typeof(ReadOnlySpan<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
 						var t when t == typeof(Span<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
-#warning TODO: PolymorphismSchema
-						_ => new Serialization(context.GetSerializer(type, null).SerializeObject)
+						_ => new Serialization(provider.GetPolymorphicSerializer(type, schema).SerializeObject)
 					};
 			}
 		}
 
-		private static IEnumerable<Delegate> CreateMemberValueDecoders(ObjectSerializationContext context, IEnumerable<SerializingMember> members, bool hasDeserializationConstructor, bool hasPriviledgedAccess)
+		private static IEnumerable<Delegate> CreateMemberValueDecoders(SerializerProvider provider, IEnumerable<SerializingMember> members, bool hasDeserializationConstructor, bool hasPriviledgedAccess)
 		{
 			foreach (var member in members)
 			{
 				var type = member.Member.GetMemberValueType();
 				var item = (Type: type, IsNullable: member.Member!.IsNullable());
 				var memberInfo = member.Member;
+				var schema = PolymorphismSchema.Create(type, member);
+
 				yield return
 					item switch
 					{
@@ -162,23 +165,22 @@ var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) &&
 						var x when x.Type == typeof(ReadOnlySequence<byte>) && x.IsNullable => DecodeReadOnlySequenceOfByteNullable,
 						var x when x.Type == typeof(ReadOnlySpan<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
 						var x when x.Type == typeof(Span<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
-#warning TODO: PolymorphismSchema
 						_ =>
 							hasDeserializationConstructor ?
-								new Deserialization(context.GetSerializer(type, null).DeserializeObject) :
+								new Deserialization(provider.GetPolymorphicSerializer(type, schema).DeserializeObject) :
 								memberInfo switch
 								{
 									PropertyInfo p =>
 										p switch
 										{
-											var pi when pi.GetSetMethod(nonPublic: hasPriviledgedAccess) != null => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
-											_ => new DeserializingFill(context.GetSerializer(type, null).DeserializeObjectTo),
+											var pi when pi.GetSetMethod(nonPublic: hasPriviledgedAccess) != null => new Deserialization(provider.GetPolymorphicSerializer(type, schema).DeserializeObject),
+											_ => new DeserializingFill(provider.GetPolymorphicSerializer(type, schema).DeserializeObjectTo),
 										},
 									FieldInfo f =>
 										f switch
 										{
-											var fi when !fi.IsInitOnly => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
-											_ => new DeserializingFill(context.GetSerializer(type, null).DeserializeObjectTo),
+											var fi when !fi.IsInitOnly => new Deserialization(provider.GetPolymorphicSerializer(type, schema).DeserializeObject),
+											_ => new DeserializingFill(provider.GetPolymorphicSerializer(type, schema).DeserializeObjectTo),
 										},
 									_ => ReflectionSerializerThrow.UnexpectedMemberType(memberInfo)
 								}
@@ -188,13 +190,15 @@ var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) &&
 
 #if FEATURE_TAP
 
-		private static IEnumerable<Delegate> CreateAsyncMemberValueDecoders(ObjectSerializationContext context, IEnumerable<SerializingMember> members, bool hasDeserializationConstructor, bool hasPriviledgedAccess)
+		private static IEnumerable<Delegate> CreateAsyncMemberValueDecoders(SerializerProvider provider, IEnumerable<SerializingMember> members, bool hasDeserializationConstructor, bool hasPriviledgedAccess)
 		{
 			foreach (var member in members)
 			{
 				var type = member.Member.GetMemberValueType();
 				var item = (Type: type, IsNullable: member.Member!.IsNullable());
 				var memberInfo = member.Member;
+				var schema = PolymorphismSchema.Create(type, member);
+
 				yield return
 					item switch
 					{
@@ -244,23 +248,22 @@ var x when (x.Type == typeof(byte[]) || x.Type == typeof(IEnumerable<byte>)) &&
 						var x when x.Type == typeof(ReadOnlySequence<byte>) && x.IsNullable => DecodeReadOnlySequenceOfByteNullableAsync,
 						var x when x.Type == typeof(ReadOnlySpan<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
 						var x when x.Type == typeof(Span<byte>) => ReflectionSerializerThrow.ByRefLikeIsNotSupported(memberInfo),
-#warning TODO: PolymorphismSchema
 						_ =>
 							hasDeserializationConstructor ?
-								new AsyncDeserialization(context.GetSerializer(type, null).DeserializeObjectAsync) :
+								new AsyncDeserialization(provider.GetPolymorphicSerializer(type, schema).DeserializeObjectAsync) :
 								memberInfo switch
 								{
 									PropertyInfo p =>
 										p switch
 										{
-											var pi when pi.GetSetMethod(nonPublic: hasPriviledgedAccess) != null => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
-											_ => new AsyncDeserializingFill(context.GetSerializer(type, null).DeserializeObjectToAsync),
+											var pi when pi.GetSetMethod(nonPublic: hasPriviledgedAccess) != null => new Deserialization(provider.GetPolymorphicSerializer(type, schema).DeserializeObject),
+											_ => new AsyncDeserializingFill(provider.GetPolymorphicSerializer(type, schema).DeserializeObjectToAsync),
 										},
 									FieldInfo f =>
 										f switch
 										{
-											var fi when !fi.IsInitOnly => new Deserialization(context.GetSerializer(type, null).DeserializeObject),
-											_ => new AsyncDeserializingFill(context.GetSerializer(type, null).DeserializeObjectToAsync),
+											var fi when !fi.IsInitOnly => new Deserialization(provider.GetPolymorphicSerializer(type, schema).DeserializeObject),
+											_ => new AsyncDeserializingFill(provider.GetPolymorphicSerializer(type, schema).DeserializeObjectToAsync),
 										},
 									_ => ReflectionSerializerThrow.UnexpectedMemberType(memberInfo)
 								}
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs
index ef9c744f5..cd3d32455 100644
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializerBuilder.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -6,7 +6,7 @@ namespace MsgPack.Serialization.ReflectionSerializers
 {
 	internal sealed class ReflectionSerializerBuilder : SerializerBuilder
 	{
-		public sealed override ObjectSerializer<T> Build<T>(ObjectSerializationContext context, SerializationTarget target)
-			=> new ReflectionSerializer<T>(context, target);
+		public sealed override ObjectSerializer<T> Build<T>(ObjectSerializationContext context, in SerializationTarget target, ISerializerGenerationOptions options)
+			=> new ReflectionSerializer<T>(context, target, options);
 	}
 }
diff --git a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs
index 7f3e8bff2..32aa55502 100644
--- a/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs
+++ b/src/MsgPack.Serialization.Reflection/Serialization/ReflectionSerializers/ReflectionSerializer`1.cs
@@ -24,20 +24,19 @@ internal sealed partial class ReflectionSerializer<T> : ObjectSerializer<T>
 		private readonly AsyncDeserializingFill _deserializeToAsync;
 #endif // FEATURE_TAP
 
-		public ReflectionSerializer(ObjectSerializationContext ownerContext, SerializationTarget target)
-			: base(ownerContext, target.GetCapabilities())
+		public ReflectionSerializer(SerializerProvider ownerProvider, in SerializationTarget target, ISerializerGenerationOptions options, PolymorphismSchema schema)
+			: base(ownerProvider, target.GetCapabilities())
 		{
-#warning TODO: PolymorphismSchema
-
+#warning TODO: AbstractCollectionSupport here
 			IReflectionObjectSerializer serializer;
 			if (!target.IsCollection)
 			{
-				serializer = new ObjectDelegateSerializer(ownerContext, target);
+				serializer = new ObjectDelegateSerializer(ownerProvider, target, options);
 			}
 			else if (target.CollectionTraits.CollectionType == CollectionKind.Array)
 			{
 #warning TODO: PolymorphismSchema
-				var itemSerializer = ownerContext.GetSerializer(target.CollectionTraits.ElementType!, null);
+				var itemSerializer = ownerProvider.GetSerializer(target.CollectionTraits.ElementType!, null);
 				serializer =
 					target.CollectionTraits.DetailedCollectionType switch
 					{
@@ -49,7 +48,8 @@ public ReflectionSerializer(ObjectSerializationContext ownerContext, Serializati
 								itemSerializer.DeserializeObjectAsync,
 #endif // FEATURE_TAP
 								target.Type,
-								target.CollectionTraits
+								target.CollectionTraits,
+								options
 							),
 						_ => new CollectionDelegateSerializer(
 							itemSerializer.SerializeObject,
@@ -58,7 +58,8 @@ public ReflectionSerializer(ObjectSerializationContext ownerContext, Serializati
 							itemSerializer.DeserializeObjectAsync,
 #endif // FEATURE_TAP
 							target.Type,
-							target.CollectionTraits
+							target.CollectionTraits,
+							options
 						)
 					};
 			}
@@ -81,7 +82,8 @@ public ReflectionSerializer(ObjectSerializationContext ownerContext, Serializati
 						valueSerializer.DeserializeObjectAsync,
 #endif // FEATURE_TAP
 						target.Type,
-						target.CollectionTraits
+						target.CollectionTraits,
+						options
 					);
 			}
 
diff --git a/src/MsgPack.Serialization/MsgPack.Serialization.csproj b/src/MsgPack.Serialization/MsgPack.Serialization.csproj
index 870dcf339..9bbf492f2 100644
--- a/src/MsgPack.Serialization/MsgPack.Serialization.csproj
+++ b/src/MsgPack.Serialization/MsgPack.Serialization.csproj
@@ -1,23 +1,27 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="..\MsgPack.Abstraction\Ensure.cs" Link="Ensure.cs" />
+    <Compile Include="..\MsgPack.Abstraction\Ensure.Enum.cs" Link="Ensure.Enum.cs" />
     <Compile Include="..\MsgPack.Abstraction\Internal\MethodImplOptionsShim.cs" Link="Internal\MethodImplOptionsShim.cs" />
+    <Compile Include="..\MsgPack.Abstraction\Internal\OptionsDefaults.cs" Link="Internal\OptionsDefaults.cs" />
+    <Compile Include="..\MsgPack.Abstraction\StringEscape.cs" Link="StringEscape.cs" />
+    <Compile Include="..\MsgPack.Core\System.Text\EncodingExtensions.cs" Link="System.Text\EncodingExtensions.cs" />
     <Compile Include="..\MsgPack\ReflectionAbstractions.cs" Link="ReflectionAbstractions.cs" />
-    <Compile Include="..\MsgPack\Serialization\BindingOptions.cs" Link="Serialization\BindingOptions.cs" />
     <Compile Include="..\MsgPack\Serialization\CollectionDetailedKind.cs" Link="Serialization\CollectionDetailedKind.cs" />
     <Compile Include="..\MsgPack\Serialization\CollectionKind.cs" Link="Serialization\CollectionKind.cs" />
     <Compile Include="..\MsgPack\Serialization\CollectionTraitOptions.cs" Link="Serialization\CollectionTraitOptions.cs" />
     <Compile Include="..\MsgPack\Serialization\CollectionTraits.cs" Link="Serialization\CollectionTraits.cs" />
     <Compile Include="..\MsgPack\Serialization\DataMemberContract.cs" Link="Serialization\DataMemberContract.cs" />
-    <Compile Include="..\MsgPack\Serialization\DateTimeConversionMethod.cs" Link="Serialization\DateTimeConversionMethod.cs" />
     <Compile Include="..\MsgPack\Serialization\DateTimeMemberConversionMethod.cs" Link="Serialization\DateTimeMemberConversionMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\DictionaryKeyTransformers.cs" Link="Serialization\DictionaryKeyTransformers.cs" />
     <Compile Include="..\MsgPack\Serialization\EnumMemberSerializationMethod.cs" Link="Serialization\EnumMemberSerializationMethod.cs" />
-    <Compile Include="..\MsgPack\Serialization\EnumSerializationMethod.cs" Link="Serialization\EnumSerializationMethod.cs" />
+    <Compile Include="..\MsgPack\Serialization\KeyNameTransformers.cs" Link="Serialization\KeyNameTransformers.cs" />
     <Compile Include="..\MsgPack\Serialization\MessagePackDateTimeMemberAttribute.cs" Link="Serialization\MessagePackDateTimeMemberAttribute.cs" />
     <Compile Include="..\MsgPack\Serialization\MessagePackDeserializationConstructorAttribute.cs" Link="Serialization\MessagePackDeserializationConstructorAttribute.cs" />
     <Compile Include="..\MsgPack\Serialization\MessagePackEnumAttribute.cs" Link="Serialization\MessagePackEnumAttribute.cs" />
@@ -30,6 +34,7 @@
     <Compile Include="..\MsgPack\Serialization\PolymorphicTypeVerificationContext.cs" Link="Serialization\PolymorphicTypeVerificationContext.cs" />
     <Compile Include="..\MsgPack\Serialization\Polymorphic\IPolymorphicHelperAttributes.cs" Link="Serialization\Polymorphic\IPolymorphicHelperAttributes.cs" />
     <Compile Include="..\MsgPack\Serialization\Polymorphic\RuntimeTypeVerifier.cs" Link="Serialization\Polymorphic\RuntimeTypeVerifier.cs" />
+    <Compile Include="..\MsgPack\Serialization\Polymorphic\TypeInfoEncoder.cs" Link="Serialization\Polymorphic\TypeInfoEncoder.cs" />
     <Compile Include="..\MsgPack\Serialization\Polymorphic\TypeInfoEncoding.cs" Link="Serialization\Polymorphic\TypeInfoEncoding.cs" />
     <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.Constructors.cs" Link="Serialization\PolymorphismSchema.Constructors.cs" />
     <Compile Include="..\MsgPack\Serialization\PolymorphismSchema.cs" Link="Serialization\PolymorphismSchema.cs" />
@@ -39,14 +44,21 @@
     <Compile Include="..\MsgPack\Serialization\PolymorphismType.cs" Link="Serialization\PolymorphismType.cs" />
     <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.CollectionTraits.cs" Link="Serialization\ReflectionExtensions.CollectionTraits.cs" />
     <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.cs" Link="Serialization\ReflectionExtensions.cs" />
+    <Compile Include="..\MsgPack\Serialization\ReflectionExtensions.InvokePreservingExtension.cs" Link="Serialization\ReflectionExtensions.InvokePreservingExtension.cs" />
     <Compile Include="..\MsgPack\Serialization\Reflection\GenericTypeExtensions.cs" Link="Serialization\Reflection\GenericTypeExtensions.cs" />
     <Compile Include="..\MsgPack\Serialization\Reflection\ReflectionExtensions.cs" Link="Serialization\Reflection\ReflectionExtensions.cs" />
     <Compile Include="..\MsgPack\Serialization\SerializationTarget.cs" Link="Serialization\SerializationTarget.cs" />
+    <Compile Include="..\MsgPack\Serialization\SerializerCapabilities.cs" Link="Serialization\SerializerCapabilities.cs" />
+    <Compile Include="..\MsgPack\Serialization\SerializerRegistrationOptions.cs" Link="Serialization\SerializerRegistrationOptions.cs" />
     <Compile Include="..\MsgPack\Serialization\SerializingMember.cs" Link="Serialization\SerializingMember.cs" />
-    <Compile Include="..\MsgPack\StringEscape.cs" Link="StringEscape.cs" />
+    <Compile Include="..\MsgPack\Serialization\TypeKeyRepository.cs" Link="Serialization\TypeKeyRepository.cs" />
     <Compile Include="..\MsgPack\TupleItems.cs" Link="TupleItems.cs" />
   </ItemGroup>
 
+  <ItemGroup Condition="!$(DefineConstants.Contains('FEATURE_COM_TYPES'))">
+    <Compile Remove="Serialization/BuiltInSerializers/FileTimeObjectSerializer.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\MsgPack.Abstraction\MsgPack.Abstraction.csproj" />
   </ItemGroup>
@@ -57,10 +69,73 @@
 
   <ItemGroup>
     <Folder Include="Internal\" />
-    <Folder Include="Serialization\Polymorphic\" />
+    <Folder Include="System.Text\" />
   </ItemGroup>
 
   <ItemGroup>
+    <None Include="Serialization\Dianostic.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Dianostic.tt</DependentUpon>
+    </None>
+    <None Include="Serialization\SerializerProviderExtensions.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>SerializerProviderExtensions.tt</DependentUpon>
+    </None>
+    <None Include="Serialization\SerializerProviderExtensions.Register.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>SerializerProviderExtensions.Register.tt</DependentUpon>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Serialization\AsyncDeserializationOperationContext.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>AsyncDeserializationOperationContext.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\AsyncSerializationOperationContext.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>AsyncSerializationOperationContext.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\BuiltinSerializers\DateTimeSerializers.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>DateTimeSerializers.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\BuiltinSerializers\EnumSerializers.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>EnumSerializers.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\DeserializationOperationContext.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>DeserializationOperationContext.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\Dianostic.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Dianostic.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\SerializationOperationContext.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>SerializationOperationContext.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\SerializerProviderExtensions.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>SerializerProviderExtensions.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Serialization\SerializerProviderExtensions.Register.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>SerializerProviderExtensions.Register.tt</DependentUpon>
+    </Compile>
     <Compile Update="Serialization\Throw.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -69,6 +144,38 @@
   </ItemGroup>
 
   <ItemGroup>
+    <None Update="Serialization\AsyncDeserializationOperationContext.tt">
+      <LastGenOutput>AsyncDeserializationOperationContext.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\AsyncSerializationOperationContext.tt">
+      <LastGenOutput>AsyncSerializationOperationContext.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\DeserializationOperationContext.tt">
+      <LastGenOutput>DeserializationOperationContext.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\Dianostic.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Dianostic.cs</LastGenOutput>
+    </None>
+    <None Update="Serialization\BuiltinSerializers\EnumSerializers.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>EnumSerializers.cs</LastGenOutput>
+    </None>
+    <None Update="Serialization\SerializationOperationContext.tt">
+      <LastGenOutput>SerializationOperationContext.cs</LastGenOutput>
+      <Generator>TextTemplatingFileGenerator</Generator>
+    </None>
+    <None Update="Serialization\SerializerProviderExtensions.Register.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>SerializerProviderExtensions.Register.cs</LastGenOutput>
+    </None>
+    <None Update="Serialization\SerializerProviderExtensions.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>SerializerProviderExtensions.cs</LastGenOutput>
+    </None>
     <None Update="Serialization\Throw.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Throw.cs</LastGenOutput>
diff --git a/src/MsgPack.Serialization/Properties/AssemblyInfo.cs b/src/MsgPack.Serialization/Properties/AssemblyInfo.cs
index ddec96c21..05978c4b8 100644
--- a/src/MsgPack.Serialization/Properties/AssemblyInfo.cs
+++ b/src/MsgPack.Serialization/Properties/AssemblyInfo.cs
@@ -9,5 +9,8 @@
 [assembly: InternalsVisibleTo("MsgPack.Serialization.ILGeneration.UnitTest")]
 [assembly: InternalsVisibleTo("MsgPack.Serialization.Reflection.UnitTest")]
 #endif // DEBUG
+[assembly: InternalsVisibleTo("MsgPack.Compatibility")]
 [assembly: InternalsVisibleTo("MsgPack.Serialization.ILGeneration")]
 [assembly: InternalsVisibleTo("MsgPack.Serialization.Reflection")]
+
+#warning TODO: Rename this package to MsgPack.Serialization.Core
diff --git a/src/MsgPack.Serialization/Serialization/AotHelper.cs b/src/MsgPack.Serialization/Serialization/AotHelper.cs
new file mode 100644
index 000000000..55a6a1ef8
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/AotHelper.cs
@@ -0,0 +1,52 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MsgPack.Serialization
+{
+	internal static partial class AotHelper
+	{
+#pragma warning disable CS0618 // Type or member is obsolete.
+		public static void HandleAotError(ExecutionEngineException ex)
+#pragma warning restore CS0618 // Type or member is obsolete.
+		{
+			string api = null;
+			if (mayBeGenericArgument.GetIsGenericType())
+			{
+				var definition = mayBeGenericArgument.GetGenericTypeDefinition();
+				if (definition == typeof(ArraySegment<>)
+#if MSGPACK_UNITY_FULL
+						|| definition == typeof( Stack<> )
+						|| definition == typeof( Queue<> )
+#endif// MSGPACK_UNITY_FULL
+					)
+				{
+					api = String.Format(CultureInfo.InvariantCulture, "MessagePackSerializer.PrepareCollectionType<{0}>", mayBeGenericArgument.GetGenericArguments()[0].GetFullName());
+				}
+				else if (definition == typeof(KeyValuePair<,>))
+				{
+					var genericArguments = mayBeGenericArgument.GetGenericArguments();
+					api = String.Format(CultureInfo.InvariantCulture, "MessagePackSerializer.PrepareDictionaryType<{0}, {1}>", genericArguments[0].GetFullName(), genericArguments[1].GetFullName());
+				}
+			}
+
+			if (api == null)
+			{
+				api = String.Format(CultureInfo.InvariantCulture, "MessagePackSerializer.PrepareType<{0}>", mayBeGenericArgument.GetFullName());
+			}
+
+			throw new InvalidOperationException(
+				String.Format(
+					CultureInfo.CurrentCulture,
+					"An AOT error is occurred. {0} is should be called in advance.",
+					api
+				),
+				mayBeAotError
+			);
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs b/src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
similarity index 91%
rename from src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
rename to src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
index f2a0fc553..67a9b6ef4 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
+++ b/src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.StreamSequence.cs
@@ -17,6 +17,6 @@ public partial class AsyncDeserializationOperationContext
 		/// <returns></returns>
 		/// <exception cref="ArgumentException"><paramref name="stream"/> is <c>null</c>.</exception>
 		public ReadOnlyStreamSequence CreateSequence(Stream stream)
-			=> new ReadOnlyStreamSequence(Ensure.NotNull(stream), this.Options.ByteBufferPool, 64 * 1024, this.Options.ClearsBuffer);
+			=> new ReadOnlyStreamSequence(Ensure.NotNull(stream), this.Options.ByteBufferPool, 64 * 1024, this.Options.ClearsByteBufferOnReturn);
 	}
 }
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs b/src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.cs
similarity index 96%
rename from src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
rename to src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.cs
index 3df936d93..620bf9ee0 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.cs
+++ b/src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.cs
@@ -20,7 +20,7 @@ public sealed partial class AsyncDeserializationOperationContext
 	{
 		public FormatDecoder Decoder { get; }
 		public DeserializationOptions Options { get; }
-		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public Encoding? StringEncoding => this.Options.DefaultStringEncoding;
 		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.tt b/src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/AsyncDeserializationOperationContext.tt
rename to src/MsgPack.Serialization/Serialization/AsyncDeserializationOperationContext.tt
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs b/src/MsgPack.Serialization/Serialization/AsyncSerializationOperationContext.cs
similarity index 96%
rename from src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
rename to src/MsgPack.Serialization/Serialization/AsyncSerializationOperationContext.cs
index 5f5a6ad23..6542284f8 100644
--- a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.cs
+++ b/src/MsgPack.Serialization/Serialization/AsyncSerializationOperationContext.cs
@@ -19,7 +19,7 @@ public sealed partial class AsyncSerializationOperationContext
 	{
 		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
-		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public Encoding? StringEncoding => this.Options.DefaultStringEncoding;
 		public SerializationMethod SerializationMethod { get; }
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
diff --git a/src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.tt b/src/MsgPack.Serialization/Serialization/AsyncSerializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/AsyncSerializationOperationContext.tt
rename to src/MsgPack.Serialization/Serialization/AsyncSerializationOperationContext.tt
diff --git a/src/MsgPack.Serialization/Serialization/BindingOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/BindingOptionsBuilder.cs
new file mode 100644
index 000000000..7ef4e13eb
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BindingOptionsBuilder.cs
@@ -0,0 +1,100 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		A builder object to configure binding options of target members.
+	/// </summary>
+	public sealed class BindingOptionsBuilder
+	{
+		internal static BindingOptionsBuilder Default { get; } = new BindingOptionsBuilder();
+
+		internal IDictionary<Type, IEnumerable<string>> IgnoringMembers { get; } = new Dictionary<Type, IEnumerable<string>>();
+
+		/// <summary>
+		///		Gets the value which indicates whether non-public member access can be assumed to be enabled relying on <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if non public types or members is non-public member access can be assumed to be enabled relying on <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		If this property is <c>true</c>, genenrators emit code with normal access even though the member or type is not public.
+		///		Note that the generated serializer will belong to the assembly which has <see cref="SerializerGenerationOptionsBuilder.RuntimeCodeGenerationAssemblyName"/> in runtime code generation,
+		///		so the assembly which declares target type must be marked with <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> for the <see cref="RuntimeCodeGenerationAssemblyName"/> without any public key.
+		///		Also, for source code generation, the assembly which declares target type must be marked with <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> for the assembly name of compiled serializer without any public key.
+		///		In this case, the assembly name will be specified via compiler option (or specified with appropriate settings in <c>.csproj</c> or to be its file name).
+		/// </remarks>
+		/// <seealso cref="SerializerGenerationOptionsBuilder.RuntimeCodeGenerationAssemblyName"/>
+		public bool AssumesInternalsVisibleTo { get; private set; }
+
+		/// <summary>
+		///		Gets a value which indicates whether non-public member access from serializer should be 
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if privileged access for non public types or members is disabled; <c>false</c>, otherwise.
+		/// </value>
+		public bool IsPrivilegedAccessDisabled { get; private set; } = true;
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="BindingOptionsBuilder"/> object.
+		/// </summary>
+		public BindingOptionsBuilder() { }
+
+		/// <summary>
+		///		Sets ignoring specified type's members.
+		/// </summary>
+		/// <param name="type">Target type.</param>
+		/// <param name="memberNames">Names of members to be ignored. The values are case sensitive. <c>null</c> or empty items will be ignored.</param>
+		/// <returns>This <see cref="BindingOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
+		public BindingOptionsBuilder IgnoreMembers(Type type, params string[] memberNames)
+			=> this.IgnoreMembers(type, memberNames as IEnumerable<string>);
+
+		/// <summary>
+		///		Sets ignoring specified type's members.
+		/// </summary>
+		/// <param name="type">Target type.</param>
+		/// <param name="memberNames">Names of members to be ignored. The values are case sensitive. <c>null</c> or empty items will be ignored.</param>
+		/// <returns>This <see cref="BindingOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException"><paramref name="type"/> is <c>null</c>.</exception>
+		public BindingOptionsBuilder IgnoreMembers(Type type, IEnumerable<string> memberNames)
+		{
+			this.IgnoringMembers[Ensure.NotNull(type)] = memberNames?.Where(m => !String.IsNullOrEmpty(m)).ToArray() ?? Enumerable.Empty<string>();
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates which indicates whether non-public member access from serializer should be 
+		/// </summary>
+		/// <returns>This <see cref="BindingOptionsBuilder"/> instance.</returns>
+		public BindingOptionsBuilder EnablePrivilegedAccess()
+		{
+			this.IsPrivilegedAccessDisabled = true;
+			return this;
+		}
+
+		public BindingOptionsBuilder DisablePrivilegedAccess()
+		{
+			this.IsPrivilegedAccessDisabled = false;
+			return this;
+		}
+
+		public BindingOptionsBuilder WithoutAssumingInternalsVisibleTo()
+		{
+			this.AssumesInternalsVisibleTo = false;
+			return this;
+		}
+
+		public BindingOptionsBuilder WithAssumingInternalsVisibleTo()
+		{
+			this.AssumesInternalsVisibleTo = true;
+			return this;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BoxedDateTimeConversionMethod.cs b/src/MsgPack.Serialization/Serialization/BoxedDateTimeConversionMethod.cs
new file mode 100644
index 000000000..7e343430e
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BoxedDateTimeConversionMethod.cs
@@ -0,0 +1,85 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Boxed representation for <see cref="DateTimeConversionMethod"/> to reduce allocation.
+	/// </summary>
+	internal sealed class BoxedDateTimeConversionMethod
+	{
+		/// <summary>
+		///		Uses <see cref="DateTime.Ticks"/> context, that is, Gregorian 0000-01-01 based, 100 nano seconds resolution. This value also preserves <see cref="DateTimeKind"/>.
+		/// </summary>
+		/// <remarks>
+		///		As of 0.6 to 0.9, this value became default. This option prevents accidental data loss.
+		/// </remarks>
+		public static BoxedDateTimeConversionMethod Native { get; } = new BoxedDateTimeConversionMethod(DateTimeConversionMethod.Native);
+
+		/// <summary>
+		///		Uses MsgPack timestamp format, that is, Gregirian 1970-01-01 based, nanoseconds resolution, with reserved ext type format.
+		/// </summary>
+		/// <remarks>
+		///		<para>
+		///			As of 1.0, this value became default.
+		///		</para>
+		///		<para>
+		///			This is best choice for interoperability and prevents accidental data loss, but old implementation does not recognize this type.
+		///			For backward compability purposes, use <see cref="Native"/> or <see cref="UnixEpoc"/> instead.
+		///		</para>
+		///		<para>
+		///			Note that <see cref="DateTime"/> and <see cref="DateTimeOffset"/> cannot hold nanoseconds value.
+		///			If you can depend on this assembly, consider <see cref="Timestamp"/> for date-time typed members to maximize interoperability for other languages.
+		///		</para>
+		/// </remarks>
+		public static BoxedDateTimeConversionMethod Timestamp { get; } = new BoxedDateTimeConversionMethod(DateTimeConversionMethod.Timestamp);
+	
+		/// <summary>
+		///		Uses Unix epoc context, that is, Gregirian 1970-01-01 based, milliseconds resolution.
+		/// </summary>
+		/// <remarks>
+		///		Many binding such as Java uses this resolution, so this option gives maximum interoperability.
+		/// </remarks>
+		public static BoxedDateTimeConversionMethod UnixEpoc { get; } = new BoxedDateTimeConversionMethod(DateTimeConversionMethod.UnixEpoc);
+
+		/// <summary>
+		///		Uses ISO 8601 extended format string, that is, "yyyy-MM-ddTHH:mm:ss.f+Z" format.
+		/// </summary>
+		/// <remarks>
+		///		This value is default in JSON codec and its family.
+		/// </remarks>
+		public static BoxedDateTimeConversionMethod Iso8601ExtendedFormat { get; } = new BoxedDateTimeConversionMethod(DateTimeConversionMethod.Iso8601ExtendedFormat);
+
+		/// <summary>
+		///		Gets an equivalent <see cref="DateTimeConversionMethod"/> value.
+		/// </summary>
+		/// <value>An equivalent <see cref="DateTimeConversionMethod"/> value.</value>
+		public DateTimeConversionMethod Value { get; }
+
+		private BoxedDateTimeConversionMethod(DateTimeConversionMethod value)
+		{
+			this.Value = value;
+		}
+
+		/// <summary>
+		///		Gets an equivalent <see cref="BoxedDateTimeConversionMethod"/> instance for specified <see cref="DateTimeConversionMethod"/> value.
+		/// </summary>
+		/// <param name="enumValue"><see cref="DateTimeConversionMethod"/> value or <c>null</c>.</param>
+		/// <returns>
+		///		An equivalent <see cref="BoxedDateTimeConversionMethod"/> instance for specified <see cref="DateTimeConversionMethod"/> value.
+		///		<c>null</c> when <paramref name="enumValue"/> is <c>null</c>.
+		/// </returns>
+		public static BoxedDateTimeConversionMethod? Get(DateTimeConversionMethod? enumValue)
+			=> enumValue switch
+			{
+				DateTimeConversionMethod.Native => Native,
+				DateTimeConversionMethod.Timestamp => Timestamp,
+				DateTimeConversionMethod.UnixEpoc => UnixEpoc,
+				DateTimeConversionMethod.Iso8601ExtendedFormat => Iso8601ExtendedFormat,
+				_ => null
+			};
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BoxedEnumSerializationMethod.cs b/src/MsgPack.Serialization/Serialization/BoxedEnumSerializationMethod.cs
new file mode 100644
index 000000000..f62672684
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BoxedEnumSerializationMethod.cs
@@ -0,0 +1,49 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Boxed representation for <see cref="DateTimeConversionMethod"/> to reduce allocation.
+	/// </summary>
+	internal sealed class BoxedEnumSerializationMethod
+	{
+		/// <summary>
+		///		Enums are serialized with their name. It is more torelant to versioning but less efficient.
+		/// </summary>
+		public static BoxedEnumSerializationMethod ByName { get; } = new BoxedEnumSerializationMethod(EnumSerializationMethod.ByName);
+
+		/// <summary>
+		///		Enums are serialized with their underlying value. It is more efficient but less torelant to versioning.
+		/// </summary>
+		public static BoxedEnumSerializationMethod ByUnderlyingValue { get; } = new BoxedEnumSerializationMethod(EnumSerializationMethod.ByUnderlyingValue);
+
+		/// <summary>
+		///		Gets an equivalent <see cref="EnumSerializationMethod"/> value.
+		/// </summary>
+		/// <value>An equivalent <see cref="EnumSerializationMethod"/> value.</value>
+		public EnumSerializationMethod Value { get; }
+
+		private BoxedEnumSerializationMethod(EnumSerializationMethod value)
+		{
+			this.Value = value;
+		}
+
+		/// <summary>
+		///		Gets an equivalent <see cref="BoxedEnumSerializationMethod"/> instance for specified <see cref="EnumSerializationMethod"/> value.
+		/// </summary>
+		/// <param name="enumValue"><see cref="DateTimeConversionMethod"/> value or <c>null</c>.</param>
+		/// <returns>
+		///		An equivalent <see cref="BoxedEnumSerializationMethod"/> instance for specified <see cref="EnumSerializationMethod"/> value.
+		///		<c>null</c> when <paramref name="enumValue"/> is <c>null</c>.
+		/// </returns>
+		public static BoxedEnumSerializationMethod? Get(EnumSerializationMethod? enumValue)
+			=> enumValue switch
+			{
+				EnumSerializationMethod.ByName => ByName,
+				EnumSerializationMethod.ByUnderlyingValue => ByUnderlyingValue,
+				_ => null
+			};
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeObjectSerializer.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeObjectSerializer.cs
new file mode 100644
index 000000000..bbd4423bb
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeObjectSerializer.cs
@@ -0,0 +1,225 @@
+// Copyright (c) FUJIWARA, Yusuke and all cotributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif // FEATURE_TAP
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	/// <summary>
+	///		Implements date time serializer for <see cref="DateTime"/>.
+	/// </summary>
+	internal sealed class DateTimeObjectSerializer : NonCollectionObjectSerializer<DateTime>
+	{
+		private readonly DateTimeConversionMethod? _method;
+
+		public DateTimeObjectSerializer(SerializerProvider ownerProvider, DateTimeConversionMethod? method)
+			: base(ownerProvider)
+		{
+			this._method = method;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, DateTime obj, IBufferWriter<byte> sink)
+			=> Serialize(ref context, obj, sink, this._method, this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions);
+
+		public static void Serialize(
+			ref SerializationOperationContext context,
+			DateTime obj,
+			IBufferWriter<byte> sink,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options
+		)
+		{
+			switch (specifiedMethod ?? options.GetDefaultDateTimeConversionMethod(context.Encoder.Options.Features))
+			{
+				case DateTimeConversionMethod.Native:
+				{
+					context.Encoder.EncodeInt64(obj.ToBinary(), sink);
+					break;
+				}
+				case DateTimeConversionMethod.UnixEpoc:
+				{
+					context.Encoder.EncodeInt64(MessagePackConvert.FromDateTime(obj), sink);
+					break;
+				}
+				case DateTimeConversionMethod.Iso8601ExtendedFormat:
+				{
+					var features = context.Encoder.Options.Features;
+					var format =
+						Iso8601.GetFormatString(
+							options.GetIso8601DecimalMark(features) ?? '.',
+							options.GetIso8601SubsecondsPrecision(features) ?? 7
+						);
+					if (format == null && (context.StringEncoding ?? features.DefaultStringEncoding) is UTF8Encoding)
+					{
+						// fast path
+						Span<byte> buffer = stackalloc byte[Iso8601.MaxLength];
+						var shouldBeTrue = Utf8Formatter.TryFormat(obj, buffer, out var written, Iso8601.StandardFormat);
+						Debug.Assert(shouldBeTrue);
+						context.Encoder.EncodeString(buffer.Slice(0, written), buffer.Length, sink, context.CancellationToken);
+					}
+					else
+					{
+						// slow path
+						Span<char> buffer = stackalloc char[Iso8601.MaxLength];
+						var shouldBeTrue = obj.TryFormat(buffer, out var written, format, CultureInfo.InvariantCulture);
+						Debug.Assert(shouldBeTrue);
+						context.Encoder.EncodeString(buffer.Slice(0, written), sink, context.StringEncoding, context.CancellationToken);
+					}
+
+					break;
+				}
+				case DateTimeConversionMethod.Timestamp:
+				default:
+				{
+					Span<byte> buffer = stackalloc byte[12];
+					var bytesUsed = Timestamp.FromDateTime(obj).Encode(buffer);
+
+					context.Encoder.EncodeExtension(ExtensionType.Timestamp, buffer.Slice(0, bytesUsed), sink);
+					break;
+				}
+			}
+		}
+
+		public sealed override DateTime Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> Deserialize(ref context, ref source, this._method, this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions);
+
+		public static DateTime Deserialize(
+			ref DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options
+		)
+		{
+			var position = source.Consumed;
+			try
+			{
+				context.Decoder.DecodeItem(ref source, out var result, context.CancellationToken);
+				position = source.Consumed - result.Value.Length;
+				return Deserialize(context, result, specifiedMethod, options, position);
+			}
+			catch (Exception ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static DateTime Deserialize(
+			in DeserializationOperationContext context,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			long position
+		)
+		{
+			try
+			{
+				long bits;
+				switch (result.ElementType)
+				{
+					case ElementType.String:
+					{
+						return DateTimeOffsetObjectSerializer.DeserializeIso8601(context, result, position).UtcDateTime;
+					}
+					case ElementType.Extension:
+					{
+						// Timestamp
+						return Timestamp.Decode(new ExtensionTypeObject(result.ExtensionType, result.ExtensionBody)).ToDateTime();
+					}
+					case ElementType.Int32:
+					{
+						Debug.Assert(result.Value.Length == sizeof(int));
+						Span<byte> buffer = stackalloc byte[sizeof(int)];
+						result.Value.CopyTo(buffer);
+						bits = BinaryPrimitives.ReadInt32BigEndian(buffer);
+						break;
+					}
+					case ElementType.Int64:
+					case ElementType.UInt64:
+					{
+						Debug.Assert(result.Value.Length == sizeof(long));
+						Span<byte> buffer = stackalloc byte[sizeof(long)];
+						result.Value.CopyTo(buffer);
+						bits = BinaryPrimitives.ReadInt64BigEndian(buffer);
+						break;
+					}
+					default:
+					{
+						Throw.InvalidDateTimeFormat(result.ElementType, typeof(DateTime), position);
+						return default; // Never reaches
+					}
+				}
+
+				// Native or UnixEpoc
+				if ((specifiedMethod ?? options.GetDefaultDateTimeConversionMethod(context.Decoder.Options.Features)) == DateTimeConversionMethod.UnixEpoc)
+				{
+					return MessagePackConvert.ToDateTime(bits);
+				}
+				else
+				{
+					return DateTime.FromBinary(bits);
+				}
+			}
+			catch (DecodeException ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+
+#if FEATURE_TAP
+		public sealed override async ValueTask<DateTime> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var position = source.Position;
+			try
+			{
+
+				DecodeItemResult result;
+				while (!TryDecodeItem(context, source, out result, out var requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken);
+				}
+
+				position = source.Position - result.Value.Length;
+				return
+					Deserialize(
+						context.AsDeserializationOperationContext(),
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						position
+					);
+			}
+			catch (Exception ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+
+		private static bool TryDecodeItem(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out DecodeItemResult result, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			context.Decoder.DecodeItem(ref reader, out result, out requestHint, context.CancellationToken);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+			return true;
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeOffsetObjectSerializer.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeOffsetObjectSerializer.cs
new file mode 100644
index 000000000..82482f0c8
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/DateTimeOffsetObjectSerializer.cs
@@ -0,0 +1,329 @@
+// Copyright (c) FUJIWARA, Yusuke and all cotributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Buffers.Text;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif // FEATURE_TAP
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	/// <summary>
+	///		Implements date time serializer for <see cref="DateTimeOffset"/>.
+	/// </summary>
+	internal sealed class DateTimeOffsetObjectSerializer : NonCollectionObjectSerializer<DateTimeOffset>
+	{
+		private readonly DateTimeConversionMethod? _method;
+
+		public DateTimeOffsetObjectSerializer(SerializerProvider ownerProvider, DateTimeConversionMethod? method)
+			: base(ownerProvider)
+		{
+			this._method = method;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, DateTimeOffset obj, IBufferWriter<byte> sink)
+		{
+			var options = this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions;
+
+			switch (this._method ?? options.GetDefaultDateTimeConversionMethod(context.Encoder.Options.Features))
+			{
+				case DateTimeConversionMethod.Native:
+				{
+					context.IncrementDepth();
+					context.Encoder.EncodeArrayStart(2, sink, context.CollectionContext);
+					context.Encoder.EncodeArrayItemStart(0, sink, context.CollectionContext);
+					DateTimeObjectSerializer.Serialize(ref context, obj.DateTime, sink, this._method, options);
+					context.Encoder.EncodeArrayItemEnd(0, sink, context.CollectionContext);
+					context.Encoder.EncodeArrayItemStart(1, sink, context.CollectionContext);
+					Debug.Assert(obj.Offset.TotalMinutes >= Int16.MinValue && obj.Offset.TotalMinutes <= Int16.MaxValue);
+					context.Encoder.EncodeInt32((int)obj.Offset.TotalMinutes, sink);
+					context.Encoder.EncodeArrayItemEnd(1, sink, context.CollectionContext);
+					context.Encoder.EncodeArrayEnd(2, sink, context.CollectionContext);
+					context.DecrementDepth();
+					break;
+				}
+				case DateTimeConversionMethod.UnixEpoc:
+				{
+					context.Encoder.EncodeInt64(MessagePackConvert.FromDateTimeOffset(obj), sink);
+					break;
+				}
+				case DateTimeConversionMethod.Iso8601ExtendedFormat:
+				{
+					var features = context.Encoder.Options.Features;
+					var format =
+						Iso8601.GetFormatString(
+							options.GetIso8601DecimalMark(features) ?? '.',
+							options.GetIso8601SubsecondsPrecision(features) ?? 7
+						);
+					if (format == null && (context.StringEncoding ?? features.DefaultStringEncoding) is UTF8Encoding)
+					{
+						// fast path
+						Span<byte> buffer = stackalloc byte[Iso8601.MaxLength];
+						var shouldBeTrue = Utf8Formatter.TryFormat(obj, buffer, out var written, Iso8601.StandardFormat);
+						Debug.Assert(shouldBeTrue);
+						context.Encoder.EncodeString(buffer.Slice(0, written), buffer.Length, sink, context.CancellationToken);
+					}
+					else
+					{
+						// slow path
+						Span<char> buffer = stackalloc char[Iso8601.MaxLength];
+						var shouldBeTrue = obj.TryFormat(buffer, out var written, format, CultureInfo.InvariantCulture);
+						Debug.Assert(shouldBeTrue);
+						context.Encoder.EncodeString(buffer.Slice(0, written), sink, context.StringEncoding, context.CancellationToken);
+					}
+
+					break;
+				}
+				case DateTimeConversionMethod.Timestamp:
+				default:
+				{
+					Span<byte> buffer = stackalloc byte[12];
+					var bytesUsed = Timestamp.FromDateTimeOffset(obj).Encode(buffer);
+
+					context.Encoder.EncodeExtension(ExtensionType.Timestamp, buffer.Slice(0, bytesUsed), sink);
+					break;
+				}
+			}
+		}
+
+		public sealed override DateTimeOffset Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var position = source.Consumed;
+			try
+			{
+				context.Decoder.DecodeItem(ref source, out var result, context.CancellationToken);
+				position = source.Consumed - result.Value.Length;
+				return
+					Deserialize(
+						context,
+						ref source,
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						ref position
+					);
+			}
+			catch (DecodeException ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static DateTimeOffset Deserialize(
+			in DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			ref long position
+		)
+		{
+			switch (result.ElementType)
+			{
+				case ElementType.String:
+				{
+					return DeserializeIso8601(context, result, position);
+				}
+				case ElementType.Extension:
+				{
+					// Timestamp
+					return Timestamp.Decode(new ExtensionTypeObject(result.ExtensionType, result.ExtensionBody)).ToDateTimeOffset();
+				}
+				case ElementType.Int32:
+				{
+					Debug.Assert(result.Value.Length == sizeof(int));
+					Span<byte> buffer = stackalloc byte[sizeof(int)];
+					result.Value.CopyTo(buffer);
+					return MessagePackConvert.ToDateTimeOffset(BinaryPrimitives.ReadInt32BigEndian(buffer));
+				}
+				case ElementType.Int64:
+				case ElementType.UInt64:
+				{
+					Debug.Assert(result.Value.Length == sizeof(long));
+					Span<byte> buffer = stackalloc byte[sizeof(long)];
+					result.Value.CopyTo(buffer);
+					return MessagePackConvert.ToDateTimeOffset(BinaryPrimitives.ReadInt64BigEndian(buffer));
+				}
+				case ElementType.Array:
+				{
+					bool canOmitIterator = result.CollectionLength >= 0;
+					var arrayStartPosition = source.Consumed;
+
+					if (canOmitIterator && result.CollectionLength != 2)
+					{
+						Throw.InvalidDateTimeOffsetArray(result.CollectionLength, position);
+					}
+
+					var decoder = context.Decoder;
+
+					var originalSourcePosition = source.Consumed;
+
+					var dateTimeBits = decoder.DecodeInt64(ref source);
+					var dateTime = DateTime.FromBinary(dateTimeBits);
+
+					position += source.Consumed - originalSourcePosition;
+
+					if (!canOmitIterator)
+					{
+						if (result.CollectionIterator.CollectionEnds(ref source))
+						{
+							Throw.InvalidDateTimeOffsetArray(1, arrayStartPosition);
+						}
+					}
+
+					var offset = TimeSpan.FromMinutes(decoder.DecodeInt16(ref source));
+
+					if (!canOmitIterator)
+					{
+						if (!result.CollectionIterator.CollectionEnds(ref source))
+						{
+							Throw.InvalidDateTimeOffsetArray(arrayStartPosition);
+						}
+					}
+
+					// The position points offset here because it will be used to report offset validation error.
+					return new DateTimeOffset(dateTime, offset);
+				}
+				default:
+				{
+					Throw.InvalidDateTimeFormat(result.ElementType, typeof(DateTimeOffset), position);
+					return default; // Never reaches
+				}
+			}
+		}
+		public static DateTimeOffset DeserializeIso8601(
+			in DeserializationOperationContext context,
+			in DecodeItemResult result,
+			long position
+		)
+		{
+			var features = context.Decoder.Options.Features;
+
+			// Iso8601
+			var encoding = context.StringEncoding ?? features.DefaultStringEncoding;
+			if (encoding is UTF8Encoding)
+			{
+				if (result.Value.Length > Iso8601.MaxLength)
+				{
+					Throw.TooLongIso8601FormatString(result.Value.Length, Iso8601.MaxLength, position);
+				}
+
+				Span<byte> buffer = stackalloc byte[unchecked((int)result.Value.Length)];
+				result.Value.CopyTo(buffer);
+				if (!Utf8Parser.TryParse(buffer, out DateTimeOffset dateTimeOffset, out _, 'o'))
+				{
+					Throw.InvalidIso8601FormatString(buffer, position);
+				}
+
+				return dateTimeOffset.UtcDateTime;
+			}
+			else
+			{
+				var maxLength = encoding.GetMaxByteCount(Iso8601.MaxLength);
+				if (result.Value.Length > maxLength)
+				{
+					Throw.TooLongIso8601FormatString(result.Value.Length, maxLength, encoding, position);
+				}
+
+				Span<byte> buffer = stackalloc byte[unchecked((int)result.Value.Length)];
+				Span<char> chars = stackalloc char[Iso8601.MaxLength];
+				int charsUsed = 0;
+				result.Value.CopyTo(buffer);
+				try
+				{
+					charsUsed = encoding.GetChars(buffer, chars);
+				}
+				catch (DecoderFallbackException ex)
+				{
+					Throw.InvalidIso8601FormatString(buffer, position, ex);
+				}
+
+				chars = chars.Slice(0, charsUsed);
+
+				if (!DateTimeOffset.TryParse(chars, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dateTimeOffset))
+				{
+					Throw.InvalidIso8601FormatString(chars.ToString(), position);
+				}
+
+				return dateTimeOffset;
+			}
+		}
+
+
+#if FEATURE_TAP
+		public sealed override async ValueTask<DateTimeOffset> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var position = source.Position;
+			try
+			{
+
+				DecodeItemResult result;
+				while (!TryDecodeItem(context, source, out result, out var requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken);
+				}
+
+				position = source.Position - result.Value.Length;
+				return
+					Deserialize(
+						context,
+						source,
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						ref position
+					);
+			}
+			catch (Exception ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static DateTimeOffset Deserialize(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			ref long position
+		)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			var deserialized =
+				Deserialize(
+					context.AsDeserializationOperationContext(),
+					ref reader,
+					result,
+					specifiedMethod,
+					options,
+					ref position
+				);
+			source.Advance(reader.Consumed);
+			return deserialized;
+		}
+
+		private static bool TryDecodeItem(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out DecodeItemResult result, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			context.Decoder.DecodeItem(ref reader, out result, out requestHint, context.CancellationToken);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+			return true;
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializerProvider.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializerProvider.cs
new file mode 100644
index 000000000..a4aa7721f
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializerProvider.cs
@@ -0,0 +1,133 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	/// <summary>
+	///		<see cref="IObjectSerializerProvider"/> for enums.
+	/// </summary>
+	internal sealed class EnumSerializerProvider : IObjectSerializerProvider
+	{
+		private readonly EnumSerializationMethod? _methodOnType;
+		private readonly ObjectSerializer _byName;
+		private readonly ObjectSerializer _byUnderlyingValue;
+		private readonly ObjectSerializer _dynamic;
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="EnumSerializerProvider"/> object.
+		/// </summary>
+		/// <param name="targetType">The type of the target enum type.</param>
+		/// <param name="ownerProvider">The provider which will own this instance.</param>
+		/// <param name="builder"><see cref="SerializerBuilder"/> which generated actual enum serializers.</param>
+		public EnumSerializerProvider(
+			Type targetType,
+			SerializerProvider ownerProvider
+		)
+		{
+			Debug.Assert(targetType.GetIsEnum());
+
+			this._methodOnType = targetType.GetCustomAttribute<MessagePackEnumAttribute>()?.SerializationMethod;
+
+			var nameMapper = SerializationMetadataFactory.GetEnumMetadata(targetType, ownerProvider.SerializerGenerationOptions.EnumOptions);
+			typeof(EnumHelper<>).MakeGenericType(targetType)
+				.GetMethod("CreateNameMapping")!
+				.CreateDelegate<CreateNameMapping>()
+				.Invoke(ownerProvider.SerializerGenerationOptions, out var serializationNameMapping, out var deserializationNameMapping);
+
+			this._byName =
+				SerializerFactory.CreateEnumSerializer(
+					targetType, 
+					ownerProvider, 
+					EnumSerializationMethod.ByName,
+					nameMapper,
+					serializationNameMapping,
+					deserializationNameMapping
+				);
+			this._byUnderlyingValue =
+				SerializerFactory.CreateEnumSerializer(
+					targetType,
+					ownerProvider,
+					EnumSerializationMethod.ByUnderlyingValue,
+					nameMapper,
+					serializationNameMapping,
+					deserializationNameMapping
+				);
+			this._dynamic = 
+				SerializerFactory.CreateObjectSerializer(
+					typeof(DynamicEnumSerializer<>), 
+					targetType, 
+					ownerProvider, 
+					this._byName, 
+					this._byUnderlyingValue
+				);
+		}
+
+		/// <inheritdoc />
+		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
+		{
+			// Specified by caller -- based on MessagePackEnumMemberAttribute
+			if (providerParameter is BoxedEnumSerializationMethod boxed)
+			{
+				return this.GetSerializer(boxed.Value);
+			}
+
+			if (providerParameter is EnumSerializationMethod enumSerializationMethod)
+			{
+				return this.GetSerializer(enumSerializationMethod);
+			}
+
+			switch (this._methodOnType)
+			{
+				case EnumSerializationMethod.ByName:
+				{
+					return this._byName;
+				}
+				case EnumSerializationMethod.ByUnderlyingValue:
+				{
+					return this._byUnderlyingValue;
+				}
+				default: // null
+				{
+					// It will determine method with codec and the option.
+					return this._dynamic;
+				}
+			}
+		}
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private ObjectSerializer GetSerializer(EnumSerializationMethod enumSerializationMethod)
+			=> enumSerializationMethod == EnumSerializationMethod.ByUnderlyingValue ? this._byUnderlyingValue : this._byName;
+
+		private delegate void CreateNameMapping(ISerializerGenerationOptions options, out object serializationNameMapping, out object deserializationNameMapping);
+
+		private static class EnumHelper<TEnum>
+		{
+			public static void CreateNameMapping(ISerializerGenerationOptions options, out object serializationNameMapping, out object deserializationNameMapping)
+			{
+				var members = (Enum.GetValues(typeof(TEnum)) as TEnum[])!;
+#pragma warning disable CS8714
+				var serializationNameMappingT = new Dictionary<TEnum, string>(members.Length);
+#pragma warning restore CS8714
+				var deserializationNameMappingT = new Dictionary<string, TEnum>(members.Length);
+
+				foreach (var member in members)
+				{
+					var asString = options.EnumOptions.NameTransformer(member!.ToString()!);
+					serializationNameMappingT[member] = asString;
+					deserializationNameMappingT[asString] = member;
+				}
+
+				serializationNameMapping = serializationNameMappingT;
+				deserializationNameMapping = deserializationNameMappingT;
+			}
+		}
+
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializer`1.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializer`1.cs
new file mode 100644
index 000000000..9b1277497
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializer`1.cs
@@ -0,0 +1,211 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	/// <summary>
+	///		Implements basic features of enum serializer.
+	/// </summary>
+	/// <typeparam name="T">The type of the target enum type.</typeparam>
+	internal abstract class EnumSerializer<T> : ObjectSerializer<T>
+	{
+		private readonly EnumSerializationMethod? _method;
+		private readonly NameMapper _nameMapper;
+
+#pragma warning disable CS8714
+		private readonly Dictionary<T, string> _serializationNameMapping;
+#pragma warning restore CS8714
+		private readonly Dictionary<string, T> _deserializationNameMapping;
+
+		protected EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714
+			Dictionary<T, string> serializationNameMapping,
+#pragma warning restore CS8714
+			Dictionary<string, T> deserializationNameMapping
+		) : base(ownerProvider, SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize)
+		{
+			Debug.Assert(typeof(T).GetIsEnum());
+			this._method = method;
+			this._nameMapper = nameMapper;
+			this._serializationNameMapping = serializationNameMapping;
+			this._deserializationNameMapping = deserializationNameMapping;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink)
+		{
+			var method = this._method ?? this.OwnerProvider.SerializerGenerationOptions.EnumOptions.GetSerializationMethod(context.Encoder.Options.Features);
+			if (method == EnumSerializationMethod.ByName)
+			{
+				if (!this._serializationNameMapping.TryGetValue(obj!, out var asString))
+				{
+					// May be undefined value which should be numeric.
+					asString = obj!.ToString() ?? String.Empty;
+				}
+
+				context.Encoder.EncodeString(this._nameMapper.SerializeName(asString), sink, context.Options.DefaultStringEncoding, context.CancellationToken);
+			}
+			else
+			{
+				this.SerializeUnderlyingValue(ref context, obj!, sink);
+			}
+		}
+
+		protected abstract void SerializeUnderlyingValue(ref SerializationOperationContext context, [DisallowNull]T obj, IBufferWriter<byte> sink);
+
+		[return: MaybeNull]
+		public sealed override T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var position = source.Consumed;
+			context.Decoder.DecodeItem(ref source, out var decoded, context.CancellationToken);
+			return this.DeserializeFromItem(context.Options.DefaultStringEncoding, decoded, position);
+		}
+
+		private T DeserializeFromItem(Encoding? defaultStringEncoding, in DecodeItemResult decoded, long position)
+		{
+			switch (decoded.ElementType)
+			{
+				case ElementType.String:
+				{
+					var asString = this._nameMapper.DeserializeName((defaultStringEncoding ?? Encoding.UTF8).GetString(decoded.Value));
+
+					if (!this._deserializationNameMapping.TryGetValue(asString, out var result))
+					{
+						if (asString.Length == 1)
+						{
+							return this.FromChar(asString[0]);
+						}
+
+						Throw.UndefinedEnumName(asString, typeof(T), position);
+						return default!; // never reaches
+					}
+
+					return result;
+				}
+				case ElementType.True:
+				{
+					return this.FromBoolean(true);
+				}
+				case ElementType.False:
+				{
+					return this.FromBoolean(false);
+				}
+				case ElementType.Int32:
+				{
+					Debug.Assert(decoded.Value.Length == sizeof(int));
+					Span<byte> buffer = stackalloc byte[sizeof(int)];
+					decoded.Value.CopyTo(buffer);
+
+					return this.FromInt32(BinaryPrimitives.ReadInt32BigEndian(buffer));
+				}
+				case ElementType.Int64:
+				{
+					Debug.Assert(decoded.Value.Length == sizeof(long));
+					Span<byte> buffer = stackalloc byte[sizeof(long)];
+					decoded.Value.CopyTo(buffer);
+
+					return this.FromInt64(BinaryPrimitives.ReadInt64BigEndian(buffer));
+				}
+				case ElementType.UInt64:
+				{
+					Debug.Assert(decoded.Value.Length == sizeof(ulong));
+					Span<byte> buffer = stackalloc byte[sizeof(ulong)];
+					decoded.Value.CopyTo(buffer);
+
+					return this.FromUInt64(BinaryPrimitives.ReadUInt64BigEndian(buffer));
+				}
+				case ElementType.Single:
+				{
+					Debug.Assert(decoded.Value.Length == sizeof(float));
+					Span<byte> buffer = stackalloc byte[sizeof(float)];
+					decoded.Value.CopyTo(buffer);
+
+					return this.FromSingle(BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32BigEndian(buffer)));
+				}
+				case ElementType.Double:
+				{
+					Debug.Assert(decoded.Value.Length == sizeof(double));
+					Span<byte> buffer = stackalloc byte[sizeof(double)];
+					decoded.Value.CopyTo(buffer);
+
+					return this.FromDouble(BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64BigEndian(buffer)));
+				}
+				default:
+				{
+					Throw.DecodedTypeIsNotEnum(decoded.ElementType, position);
+					return default!; // Never reaches
+				}
+			}
+		}
+
+		protected abstract T FromBoolean(bool value);
+
+		protected abstract T FromChar(char value);
+		
+		protected abstract T FromInt32(int value);
+		
+		protected abstract T FromInt64(long value);
+		
+		protected abstract T FromUInt64(ulong value);
+		
+		protected abstract T FromSingle(float value);
+		
+		protected abstract T FromDouble(double value);
+
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(typeof(T));
+			return default;
+		}
+
+#if FEATURE_TAP
+
+		public override async ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			DecodeItemResult decoded;
+			var initialPosition = source.Position;
+
+			while (TryDecodeItem(context, source, out decoded, out var requestHint))
+			{
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
+
+			return this.DeserializeFromItem(context.Options.DefaultStringEncoding, decoded, source.Position);
+		}
+
+		private static bool TryDecodeItem(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out DecodeItemResult decoded, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			context.Decoder.DecodeItem(ref reader, out decoded, out requestHint, context.CancellationToken);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+			return true;
+		}
+
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(typeof(T));
+			return default;
+		}
+
+#endif // FEATURE_TAP
+
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.cs
new file mode 100644
index 000000000..72954a5b7
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.cs
@@ -0,0 +1,1251 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+
+namespace MsgPack.Serialization
+{
+	internal partial class SerializerFactory
+	{
+		private static Type GetEnumSerializerGenericTypeDefinition(Type underlyingType)
+		{
+			if (underlyingType == typeof(System.Int32))
+			{
+				return typeof(BuiltinSerializers.Int32EnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Int64))
+			{
+				return typeof(BuiltinSerializers.Int64EnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.UInt32))
+			{
+				return typeof(BuiltinSerializers.UInt32EnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.UInt64))
+			{
+				return typeof(BuiltinSerializers.UInt64EnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Byte))
+			{
+				return typeof(BuiltinSerializers.ByteEnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Int16))
+			{
+				return typeof(BuiltinSerializers.Int16EnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.SByte))
+			{
+				return typeof(BuiltinSerializers.SByteEnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.UInt16))
+			{
+				return typeof(BuiltinSerializers.UInt16EnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Boolean))
+			{
+				return typeof(BuiltinSerializers.BooleanEnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Char))
+			{
+				return typeof(BuiltinSerializers.CharEnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Single))
+			{
+				return typeof(BuiltinSerializers.SingleEnumSerializer<>);
+			}
+
+			if (underlyingType == typeof(System.Double))
+			{
+				return typeof(BuiltinSerializers.DoubleEnumSerializer<>);
+			}
+
+			Throw.UnsupportedEnumUnderlyingType(underlyingType);
+			return null!; // Never reaches
+		}
+	}
+
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class Int32EnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public Int32EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeInt32(*(Int32*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Int32));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Int32));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < Int32.MinValue || value > Int32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(Int32), value);
+			}
+			var underlyingValue = unchecked((Int32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > (UInt64)Int32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(Int32), value);
+			}
+			var underlyingValue = unchecked((Int32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < Int32.MinValue || value > Int32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(Int32), value);
+			}
+			var underlyingValue = unchecked((Int32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < Int32.MinValue || value > Int32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Int32), value);
+			}
+			var underlyingValue = unchecked((Int32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class Int64EnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public Int64EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeInt64(*(Int64*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Int64));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Int64));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			var underlyingValue = unchecked((Int64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > (UInt64)Int64.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(Int64), value);
+			}
+			var underlyingValue = unchecked((Int64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < Int64.MinValue || value > Int64.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(Int64), value);
+			}
+			var underlyingValue = unchecked((Int64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < Int64.MinValue || value > Int64.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Int64), value);
+			}
+			var underlyingValue = unchecked((Int64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class UInt32EnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public UInt32EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeUInt32(*(UInt32*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(UInt32));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(UInt32));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			if (value < 0)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(UInt32), value);
+			}
+			var underlyingValue = unchecked((UInt32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < 0 || value > UInt32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(UInt32), value);
+			}
+			var underlyingValue = unchecked((UInt32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > UInt32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(UInt32), value);
+			}
+			var underlyingValue = unchecked((UInt32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < 0 || value > UInt32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(UInt32), value);
+			}
+			var underlyingValue = unchecked((UInt32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < 0 || value > UInt32.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(UInt32), value);
+			}
+			var underlyingValue = unchecked((UInt32)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class UInt64EnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public UInt64EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeUInt64(*(UInt64*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(UInt64));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(UInt64));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			var underlyingValue = unchecked((UInt64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < 0)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(UInt64), value);
+			}
+			var underlyingValue = unchecked((UInt64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < 0 || value > UInt64.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(UInt64), value);
+			}
+			var underlyingValue = unchecked((UInt64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < 0 || value > UInt64.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(UInt64), value);
+			}
+			var underlyingValue = unchecked((UInt64)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class ByteEnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public ByteEnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeUInt32(*(Byte*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Byte));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Byte));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			if (value < 0 || value > Byte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(Byte), value);
+			}
+			var underlyingValue = unchecked((Byte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < 0 || value > Byte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(Byte), value);
+			}
+			var underlyingValue = unchecked((Byte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > Byte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(Byte), value);
+			}
+			var underlyingValue = unchecked((Byte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < 0 || value > Byte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(Byte), value);
+			}
+			var underlyingValue = unchecked((Byte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < 0 || value > Byte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Byte), value);
+			}
+			var underlyingValue = unchecked((Byte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class Int16EnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public Int16EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeInt32(*(Int16*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Int16));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Int16));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			if (value < Int16.MinValue || value > Int16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(Int16), value);
+			}
+			var underlyingValue = unchecked((Int16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < Int16.MinValue || value > Int16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(Int16), value);
+			}
+			var underlyingValue = unchecked((Int16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > (UInt64)Int16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(Int16), value);
+			}
+			var underlyingValue = unchecked((Int16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < Int16.MinValue || value > Int16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(Int16), value);
+			}
+			var underlyingValue = unchecked((Int16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < Int16.MinValue || value > Int16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Int16), value);
+			}
+			var underlyingValue = unchecked((Int16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class SByteEnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public SByteEnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeInt32(*(SByte*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(SByte));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(SByte));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			if (value < SByte.MinValue || value > SByte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(SByte), value);
+			}
+			var underlyingValue = unchecked((SByte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < SByte.MinValue || value > SByte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(SByte), value);
+			}
+			var underlyingValue = unchecked((SByte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > (UInt64)SByte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(SByte), value);
+			}
+			var underlyingValue = unchecked((SByte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < SByte.MinValue || value > SByte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(SByte), value);
+			}
+			var underlyingValue = unchecked((SByte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < SByte.MinValue || value > SByte.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(SByte), value);
+			}
+			var underlyingValue = unchecked((SByte)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class UInt16EnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public UInt16EnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeUInt32(*(UInt16*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(UInt16));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(UInt16));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			if (value < 0 || value > UInt16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(UInt16), value);
+			}
+			var underlyingValue = unchecked((UInt16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			if (value < 0 || value > UInt16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(UInt16), value);
+			}
+			var underlyingValue = unchecked((UInt16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			if (value > UInt16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(UInt16), value);
+			}
+			var underlyingValue = unchecked((UInt16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			if (value < 0 || value > UInt16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Single), typeof(T), typeof(UInt16), value);
+			}
+			var underlyingValue = unchecked((UInt16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < 0 || value > UInt16.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(UInt16), value);
+			}
+			var underlyingValue = unchecked((UInt16)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class BooleanEnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public BooleanEnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeBoolean(*(Boolean*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Boolean));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(Boolean));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(Boolean));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(Boolean));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Single), typeof(T), typeof(Boolean));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Boolean));
+			return default!; // Never reaches.
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class CharEnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public CharEnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				var c = *(char*)(&value);
+				Span<char> input = stackalloc char[1];
+				input[0] = c;
+				context.Encoder.EncodeString(input, sink, context.StringEncoding);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Char));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Int32), typeof(T), typeof(Char));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Int64), typeof(T), typeof(Char));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(UInt64), typeof(T), typeof(Char));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Single), typeof(T), typeof(Char));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Char));
+			return default!; // Never reaches.
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class SingleEnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public SingleEnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeSingle(*(Single*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Single));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Single));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			var underlyingValue = unchecked((Single)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			var underlyingValue = unchecked((Single)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			var underlyingValue = unchecked((Single)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			if (value < Single.MinValue || value > Single.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(Double), typeof(T), typeof(Single), value);
+			}
+			var underlyingValue = unchecked((Single)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class DoubleEnumSerializer<T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public DoubleEnumSerializer(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.EncodeDouble(*(Double*)(&value), sink);
+			}
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Boolean), typeof(T), typeof(Double));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+			Throw.IncompatibleEnumUnderlyingValue(typeof(Char), typeof(T), typeof(Double));
+			return default!; // Never reaches.
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+			var underlyingValue = unchecked((Double)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+			var underlyingValue = unchecked((Double)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+			var underlyingValue = unchecked((Double)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+			var underlyingValue = unchecked((Double)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+		}
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.tt b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.tt
new file mode 100644
index 000000000..feecf2863
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/EnumSerializers.tt
@@ -0,0 +1,334 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+// According to ECMA 335 II.14.3, following types can be enum's underlying type:
+// * Boolean
+// * Char
+// * SByte
+// * Int16
+// * Int32
+// * Int64
+// * IntPtr (nint)
+// * Byte
+// * UInt16
+// * UInt32
+// * UInt64
+// * IntPtr (nuint)
+// And we add and remove following:
+// * Add Single -- CLR and CoreCLR support it.
+// * Add Double -- CLR and CoreCLR support it.
+// * Remove IntPtr -- CLR and CoreCLR do not support it, and CLI spec does not allow native int typed literal.
+// * Remove UIntPtr -- CLR and CoreCLR do not support it, and CLI spec does not allow native unsigned int typed literal.
+
+var types =
+	new []
+	{
+		typeof(Int32),
+		typeof(Int64),
+		typeof(UInt32),
+		typeof(UInt64),
+		typeof(Byte),
+		typeof(Int16),
+		typeof(SByte),
+		typeof(UInt16),
+		typeof(Boolean),
+		typeof(Char),
+		typeof(Single),
+		typeof(Double),
+	};
+var treats =
+	new Dictionary<Type, (NumberTreats Treats, int Precision)>
+	{
+		{ typeof(Int32),	(NumberTreats.SignedInteger,	4) },
+		{ typeof(Int64),	(NumberTreats.SignedInteger,	8) },
+		{ typeof(UInt32),	(NumberTreats.UnsignedInteger,	4) },
+		{ typeof(UInt64),	(NumberTreats.UnsignedInteger,	8) },
+		{ typeof(Byte),		(NumberTreats.UnsignedInteger,	1) },
+		{ typeof(Int16),	(NumberTreats.SignedInteger,	2) },
+		{ typeof(SByte),	(NumberTreats.SignedInteger,	1) },
+		{ typeof(UInt16),	(NumberTreats.UnsignedInteger,	2) },
+		{ typeof(Boolean),	(NumberTreats.None,				0) },
+		{ typeof(Char),		(NumberTreats.None,				2) },
+		{ typeof(Single),	(NumberTreats.Real,				40) },
+		{ typeof(Double),	(NumberTreats.Real,				80) },
+	};
+
+#>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+
+namespace MsgPack.Serialization
+{
+	internal partial class SerializerFactory
+	{
+		private static Type GetEnumSerializerGenericTypeDefinition(Type underlyingType)
+		{
+<#
+foreach (var type in types)
+{
+	var typeName = GetTypeName(type);
+#>
+			if (underlyingType == typeof(<#= type #>))
+			{
+				return typeof(BuiltinSerializers.<#= typeName #><>);
+			}
+
+<#
+}
+#>
+			Throw.UnsupportedEnumUnderlyingType(underlyingType);
+			return null!; // Never reaches
+		}
+	}
+
+<#
+foreach (var type in types)
+{
+	var typeName = GetTypeName(type);
+#>
+}
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal sealed class <#= typeName #><T> : EnumSerializer<T>
+		where T : unmanaged // Enums are always unmanaged
+	{
+		public <#= typeName #>(
+			SerializerProvider ownerProvider,
+			EnumSerializationMethod? method,
+			NameMapper nameMapper,
+#pragma warning disable CS8714 
+			Dictionary<T, string> serializationNameMapping, 
+#pragma warning restore CS8714 
+			Dictionary<string, T> deserializationNameMapping
+		) : base (ownerProvider, method, nameMapper, serializationNameMapping, deserializationNameMapping) { }
+
+		protected sealed override void SerializeUnderlyingValue(ref SerializationOperationContext context, T value, IBufferWriter<byte> sink)
+		{
+<#
+	WriteSerialize(type, treats[type]);
+#>
+		}
+
+		protected sealed override T FromBoolean(bool value)
+		{
+<#
+	WriteFrom(typeof(bool), type, treats);
+#>
+		}
+
+		protected sealed override T FromChar(char value)
+		{
+<#
+	WriteFrom(typeof(char), type, treats);
+#>
+		}
+
+		protected sealed override T FromInt32(int value)
+		{
+<#
+	WriteFrom(typeof(int), type, treats);
+#>
+		}
+
+		protected sealed override T FromInt64(long value)
+		{
+<#
+	WriteFrom(typeof(long), type, treats);
+#>
+		}
+
+		protected sealed override T FromUInt64(ulong value)
+		{
+<#
+	WriteFrom(typeof(ulong), type, treats);
+#>
+		}
+
+		protected sealed override T FromSingle(float value)
+		{
+<#
+	WriteFrom(typeof(float), type, treats);
+#>
+		}
+
+		protected sealed override T FromDouble(double value)
+		{
+<#
+	WriteFrom(typeof(double), type, treats);
+#>
+		}
+	}
+<#
+}
+#>
+
+}
+<#+
+static string GetTypeName(Type targetType) => $"{targetType.Name}EnumSerializer";
+
+void WriteSerialize(Type underlyingType, (NumberTreats, int) metadata)
+{
+	var (treats, precision) = metadata;
+
+	if (underlyingType == typeof(char))
+	{
+#>
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				var c = *(char*)(&value);
+				Span<char> input = stackalloc char[1];
+				input[0] = c;
+				context.Encoder.EncodeString(input, sink, context.StringEncoding);
+			}
+<#+
+	}
+	else
+	{
+		var suffix = underlyingType.Name;
+		if (precision < 4 && precision != 0)
+		{
+			suffix = (treats & NumberTreats.Signed) == 0 ? "UInt32" : "Int32";
+		}
+#>
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				context.Encoder.Encode<#= suffix #>(*(<#= underlyingType.Name #>*)(&value), sink);
+			}
+<#+
+	}
+}
+
+void WriteFrom(Type sourceType, Type underlyingType, IReadOnlyDictionary<Type, (NumberTreats Treats, int Precision)> metadata)
+{
+	if (sourceType == underlyingType)
+	{
+#>
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+<#+
+		return;
+	}
+
+	var source = metadata[sourceType];
+	var underlying = metadata[underlyingType];
+
+	if ((source.Treats & NumberTreats.Number) == 0 || (underlying.Treats & NumberTreats.Number) == 0)
+	{
+#>
+			Throw.IncompatibleEnumUnderlyingValue(typeof(<#= sourceType.Name #>), typeof(T), typeof(<#= underlyingType.Name#>));
+			return default!; // Never reaches.
+<#+
+		return;
+	}
+
+	// Now, number.
+
+	var sourceSigned = (source.Treats & NumberTreats.Signed) != 0;
+	var underlyingSigned = (underlying.Treats & NumberTreats.Signed) != 0;
+
+	// check range.
+	if (underlying.Precision <= source.Precision)
+	{
+
+		// signed -> unsigned
+		if (sourceSigned == underlyingSigned)
+		{
+			// simple range check
+			if (sourceSigned)
+			{
+#>
+			if (value < <#= underlyingType.Name #>.MinValue || value > <#= underlyingType.Name #>.MaxValue)
+<#+
+			}
+			else
+			{
+#>
+			if (value > <#= underlyingType.Name #>.MaxValue)
+<#+
+			}
+		}
+		else if (sourceSigned && !underlyingSigned)
+		{
+			// signed -> unsigned
+			if (underlying.Precision < source.Precision)
+			{
+#>
+			if (value < 0 || value > <#= underlyingType.Name #>.MaxValue)
+<#+
+			}
+			else
+			{
+#>
+			if (value < 0)
+<#+
+			}
+		}
+		else
+		{
+			// unsigned -> signed
+#>
+			if (value > (<#= sourceType.Name #>)<#= underlyingType.Name #>.MaxValue)
+<#+
+		}
+#>
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(<#= sourceType.Name #>), typeof(T), typeof(<#= underlyingType.Name#>), value);
+			}
+<#+
+	}
+	else if (!sourceSigned && underlyingSigned && (underlying.Treats & NumberTreats.Integral) != 0)
+	{
+		// unsigned -> signed
+#>
+			if (value > (<#= sourceType.Name #>)<#= underlyingType.Name #>.MaxValue)
+			{
+				Throw.OutOfRangeEnumUnderlyingValue(typeof(<#= sourceType.Name #>), typeof(T), typeof(<#= underlyingType.Name#>), value);
+			}
+<#+
+	}
+#>
+			var underlyingValue = unchecked((<#= underlyingType.Name #>)value);
+			// Avoid Unsafe because of .NET 3.5 support.
+			unsafe
+			{
+				return *(T*)(&value);
+			}
+<#+
+#>
+
+<#+
+}
+
+[Flags]
+enum NumberTreats
+{
+	None = 0,
+	Number = 0x1,
+	Signed = 0x2,
+	Integral = 0x4,
+	SignedInteger = Number | Signed | Integral,
+	UnsignedInteger = Number | Integral,
+	Real = Number | Signed
+}
+#>
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/FileTimeObjectSerializer.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/FileTimeObjectSerializer.cs
new file mode 100644
index 000000000..6a9642fb6
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/FileTimeObjectSerializer.cs
@@ -0,0 +1,265 @@
+// Copyright (c) FUJIWARA, Yusuke and all cotributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Diagnostics;
+using System.Globalization;
+#if FEATURE_COM_TYPES
+using System.Runtime.InteropServices.ComTypes;
+#endif // FEATURE_COM_TYPES
+using System.Text;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif // FEATURE_TAP
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	/// <summary>
+	///		Implements date time serializer for <see cref="FILETIME"/>.
+	/// </summary>
+	internal sealed class FileTimeObjectSerializer : NonCollectionObjectSerializer<FILETIME>
+	{
+		private readonly DateTimeConversionMethod? _method;
+
+		public FileTimeObjectSerializer(SerializerProvider ownerProvider, DateTimeConversionMethod? method)
+			: base(ownerProvider)
+		{
+			this._method = method;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, FILETIME obj, IBufferWriter<byte> sink)
+		{
+			var options = this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions;
+
+			switch (this._method ?? options.GetDefaultDateTimeConversionMethod(context.Encoder.Options.Features))
+			{
+				case DateTimeConversionMethod.Native:
+				{
+					context.Encoder.EncodeInt64(obj.ToDateTime().ToBinary(), sink);
+					break;
+				}
+				case DateTimeConversionMethod.UnixEpoc:
+				{
+					context.Encoder.EncodeInt64(MessagePackConvert.FromDateTime(obj.ToDateTime()), sink);
+					break;
+				}
+				case DateTimeConversionMethod.Iso8601ExtendedFormat:
+				{
+					var features = context.Encoder.Options.Features;
+					var format =
+						Iso8601.GetFormatString(
+							options.GetIso8601DecimalMark(features) ?? '.',
+							options.GetIso8601SubsecondsPrecision(features) ?? 0
+						) ?? "o";
+					// slow path
+					Span<char> buffer = stackalloc char[Iso8601.MaxLength];
+					var shouldBeTrue = obj.ToDateTime().TryFormat(buffer, out var written, format, CultureInfo.InvariantCulture);
+					Debug.Assert(shouldBeTrue);
+					context.Encoder.EncodeString(buffer.Slice(0, written), sink, context.StringEncoding, context.CancellationToken);
+
+					break;
+				}
+				case DateTimeConversionMethod.Timestamp:
+				default:
+				{
+					Span<byte> buffer = stackalloc byte[12];
+					var bytesUsed = Timestamp.FromDateTime(obj.ToDateTime()).Encode(buffer);
+					context.Encoder.EncodeExtension(ExtensionType.Timestamp, buffer.Slice(0, bytesUsed), sink);
+					break;
+				}
+			}
+		}
+
+		public sealed override FILETIME Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var position = source.Consumed;
+			try
+			{
+				context.Decoder.DecodeItem(ref source, out var result, context.CancellationToken);
+				position = source.Consumed - result.Value.Length;
+				return
+					Deserialize(
+						context,
+						ref source,
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						ref position
+					);
+			}
+			catch (DecodeException ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static FILETIME Deserialize(
+			in DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			ref long position
+		)
+		{
+			long bits;
+			switch (result.ElementType)
+			{
+				case ElementType.String:
+				{
+					return DeserializeIso8601(context, result, position);
+				}
+				case ElementType.Extension:
+				{
+					// Timestamp
+					return Timestamp.Decode(new ExtensionTypeObject(result.ExtensionType, result.ExtensionBody)).ToDateTime().ToWin32FileTimeUtc();
+				}
+				case ElementType.Int32:
+				{
+					Debug.Assert(result.Value.Length == sizeof(int));
+					Span<byte> buffer = stackalloc byte[sizeof(int)];
+					result.Value.CopyTo(buffer);
+					bits = BinaryPrimitives.ReadInt32BigEndian(buffer);
+					break;
+				}
+				case ElementType.Int64:
+				case ElementType.UInt64:
+				{
+					Debug.Assert(result.Value.Length == sizeof(long));
+					Span<byte> buffer = stackalloc byte[sizeof(long)];
+					result.Value.CopyTo(buffer);
+					bits = BinaryPrimitives.ReadInt64BigEndian(buffer);
+					break;
+				}
+				default:
+				{
+					Throw.InvalidDateTimeFormat(result.ElementType, typeof(FILETIME), position);
+					return default; // Never reaches
+				}
+			}
+
+			// Native or UnixEpoc
+			if ((specifiedMethod ?? options.GetDefaultDateTimeConversionMethod(context.Decoder.Options.Features)) == DateTimeConversionMethod.UnixEpoc)
+			{
+				return MessagePackConvert.ToDateTime(bits).ToWin32FileTimeUtc();
+			}
+			else
+			{
+				return DateTime.FromBinary(bits).ToWin32FileTimeUtc();
+			}
+		}
+		private static FILETIME DeserializeIso8601(
+			in DeserializationOperationContext context,
+			in DecodeItemResult result,
+			long position
+		)
+		{
+			var features = context.Decoder.Options.Features;
+
+			// Iso8601
+			var encoding = context.StringEncoding ?? features.DefaultStringEncoding;
+#warning TODO: Optimize for Utf8Encoding
+
+			var maxLength = encoding.GetMaxByteCount(Iso8601.MaxLength);
+			if (result.Value.Length > maxLength)
+			{
+				Throw.TooLongIso8601FormatString(result.Value.Length, maxLength, encoding, position);
+			}
+
+			Span<byte> buffer = stackalloc byte[unchecked((int)result.Value.Length)];
+			Span<char> chars = stackalloc char[Iso8601.MaxLength];
+			int charsUsed = 0;
+			result.Value.CopyTo(buffer);
+			try
+			{
+				charsUsed = encoding.GetChars(buffer, chars);
+			}
+			catch (DecoderFallbackException ex)
+			{
+				Throw.InvalidIso8601FormatString(buffer, position, ex);
+			}
+
+			chars = chars.Slice(0, charsUsed);
+
+			if (!DateTime.TryParseExact(chars, "o", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dateTime))
+			{
+				Throw.InvalidIso8601FormatString(chars.ToString(), position);
+			}
+
+			return dateTime.ToWin32FileTimeUtc();
+		}
+
+
+#if FEATURE_TAP
+		public sealed override async ValueTask<FILETIME> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var position = source.Position;
+			try
+			{
+
+				DecodeItemResult result;
+				while (!TryDecodeItem(context, source, out result, out var requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken);
+				}
+
+				position = source.Position - result.Value.Length;
+				return
+					Deserialize(
+						context,
+						source,
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						ref position
+					);
+			}
+			catch (Exception ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static FILETIME Deserialize(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			ref long position
+		)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			var deserialized =
+				Deserialize(
+					context.AsDeserializationOperationContext(),
+					ref reader,
+					result,
+					specifiedMethod,
+					options,
+					ref position
+				);
+			source.Advance(reader.Consumed);
+			return deserialized;
+		}
+
+		private static bool TryDecodeItem(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out DecodeItemResult result, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			context.Decoder.DecodeItem(ref reader, out result, out requestHint, context.CancellationToken);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+			return true;
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/InternalDateTimeExtensions.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/InternalDateTimeExtensions.cs
new file mode 100644
index 000000000..40fbeedb8
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/InternalDateTimeExtensions.cs
@@ -0,0 +1,38 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+#if FEATURE_COM_TYPES
+using System.Runtime.InteropServices.ComTypes;
+#endif // FEATURE_COM_TYPES
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	internal static class InternalDateTimeExtensions
+	{
+#if FEATURE_COM_TYPES
+		private static readonly DateTime _fileTimeEpocUtc = new DateTime(1601, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+		public static DateTime ToDateTime(this FILETIME source)
+		{
+			// DateTime.FromFileTimeUtc in Mono 2.10.x does not return Utc DateTime (Mono issue #2936), so do convert manually to ensure returned DateTime is UTC.
+			return
+				_fileTimeEpocUtc.AddTicks(
+					unchecked(((long)source.dwHighDateTime << 32) | (source.dwLowDateTime & 0xffffffff))
+				);
+		}
+
+		public static FILETIME ToWin32FileTimeUtc(this DateTime source)
+		{
+			var value = source.ToFileTimeUtc();
+			return
+				new FILETIME
+				{
+					dwHighDateTime = unchecked((int)(value >> 32)),
+					dwLowDateTime = unchecked((int)(value & 0xffffffff))
+				};
+		}
+#endif // FEATURE_COM_TYPES
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/BuiltinSerializers/TimestampObjectSerializer.cs b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/TimestampObjectSerializer.cs
new file mode 100644
index 000000000..b0eb2f1fa
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/BuiltinSerializers/TimestampObjectSerializer.cs
@@ -0,0 +1,256 @@
+// Copyright (c) FUJIWARA, Yusuke and all cotributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif // FEATURE_TAP
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.BuiltinSerializers
+{
+	/// <summary>
+	///		Implements date time serializer for <see cref="Timestamp"/>.
+	/// </summary>
+	internal sealed class TimestampObjectSerializer : NonCollectionObjectSerializer<Timestamp>
+	{
+		private readonly DateTimeConversionMethod? _method;
+
+		public TimestampObjectSerializer(SerializerProvider ownerProvider, DateTimeConversionMethod? method)
+			: base(ownerProvider)
+		{
+			this._method = method;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, Timestamp obj, IBufferWriter<byte> sink)
+		{
+			var options = this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions;
+
+			switch (this._method ?? options.GetDefaultDateTimeConversionMethod(context.Encoder.Options.Features))
+			{
+				case DateTimeConversionMethod.Native:
+				{
+					context.Encoder.EncodeInt64(obj.ToDateTime().ToBinary(), sink);
+					break;
+				}
+				case DateTimeConversionMethod.UnixEpoc:
+				{
+					context.Encoder.EncodeInt64(MessagePackConvert.FromDateTime(obj.ToDateTime()), sink);
+					break;
+				}
+				case DateTimeConversionMethod.Iso8601ExtendedFormat:
+				{
+					//var features = context.Encoder.Options.Features;
+
+#warning TODO: Custom precision support.
+					//var format =
+					//	Iso8601.GetFormatString(
+					//		options.GetIso8601DecimalMark(features) ?? '.',
+					//		options.GetIso8601SubsecondsPrecision(features) ?? 9
+					//	);
+					context.Encoder.EncodeString(obj.ToString(), sink, context.StringEncoding, context.CancellationToken);
+					break;
+				}
+				case DateTimeConversionMethod.Timestamp:
+				default:
+				{
+					Span<byte> buffer = stackalloc byte[12];
+					var bytesUsed = obj.Encode(buffer);
+					context.Encoder.EncodeExtension(ExtensionType.Timestamp, buffer.Slice(0, bytesUsed), sink);
+					break;
+				}
+			}
+		}
+
+		public sealed override Timestamp Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			var position = source.Consumed;
+			try
+			{
+				context.Decoder.DecodeItem(ref source, out var result, context.CancellationToken);
+				position = source.Consumed - result.Value.Length;
+				return
+					Deserialize(
+						context,
+						ref source,
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						ref position
+					);
+			}
+			catch (DecodeException ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static Timestamp Deserialize(
+			in DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			ref long position
+		)
+		{
+			long bits;
+			switch (result.ElementType)
+			{
+				case ElementType.String:
+				{
+					return DeserializeIso8601(context, result, position);
+				}
+				case ElementType.Extension:
+				{
+					// Timestamp
+					return Timestamp.Decode(new ExtensionTypeObject(result.ExtensionType, result.ExtensionBody)).ToDateTimeOffset();
+				}
+				case ElementType.Int32:
+				{
+					Debug.Assert(result.Value.Length == sizeof(int));
+					Span<byte> buffer = stackalloc byte[sizeof(int)];
+					result.Value.CopyTo(buffer);
+					bits = BinaryPrimitives.ReadInt32BigEndian(buffer);
+					break;
+				}
+				case ElementType.Int64:
+				case ElementType.UInt64:
+				{
+					Debug.Assert(result.Value.Length == sizeof(long));
+					Span<byte> buffer = stackalloc byte[sizeof(long)];
+					result.Value.CopyTo(buffer);
+					bits = BinaryPrimitives.ReadInt64BigEndian(buffer);
+					break;
+				}
+				default:
+				{
+					Throw.InvalidDateTimeFormat(result.ElementType, typeof(Timestamp), position);
+					return default; // Never reaches
+				}
+			}
+
+			// Native or UnixEpoc
+			if ((specifiedMethod ?? options.GetDefaultDateTimeConversionMethod(context.Decoder.Options.Features)) == DateTimeConversionMethod.UnixEpoc)
+			{
+				return Timestamp.FromDateTime(MessagePackConvert.ToDateTime(bits));
+			}
+			else
+			{
+				return Timestamp.FromDateTime(DateTime.FromBinary(bits));
+			}
+		}
+		private static Timestamp DeserializeIso8601(
+			in DeserializationOperationContext context,
+			in DecodeItemResult result,
+			long position
+		)
+		{
+			var features = context.Decoder.Options.Features;
+
+			// Iso8601
+			var encoding = context.StringEncoding ?? features.DefaultStringEncoding;
+#warning TODO: Optimize for Utf8Encoding
+
+			var maxLength = encoding.GetMaxByteCount(Iso8601.MaxLength);
+			if (result.Value.Length > maxLength)
+			{
+				Throw.TooLongIso8601FormatString(result.Value.Length, maxLength, encoding, position);
+			}
+
+			Span<byte> buffer = stackalloc byte[unchecked((int)result.Value.Length)];
+			result.Value.CopyTo(buffer);
+			string chars = default!;
+			try
+			{
+				chars = encoding.GetString(buffer);
+			}
+			catch (DecoderFallbackException ex)
+			{
+				Throw.InvalidIso8601FormatString(buffer, position, ex);
+			}
+
+			if (!Timestamp.TryParseExact(chars, "o", CultureInfo.InvariantCulture, DateTimeStyles.None, out var timestamp))
+			{
+				Throw.InvalidIso8601FormatString(chars, position);
+			}
+
+			return timestamp;
+		}
+
+
+#if FEATURE_TAP
+		public sealed override async ValueTask<Timestamp> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			var position = source.Position;
+			try
+			{
+
+				DecodeItemResult result;
+				while (!TryDecodeItem(context, source, out result, out var requestHint))
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken);
+				}
+
+				position = source.Position - result.Value.Length;
+				return
+					Deserialize(
+						context,
+						source,
+						result,
+						this._method,
+						this.OwnerProvider.SerializerGenerationOptions.DateTimeOptions,
+						ref position
+					);
+			}
+			catch (Exception ex)
+			{
+				Throw.DecodeFailure(ex, position);
+				throw; // Never reaches
+			}
+		}
+		private static Timestamp Deserialize(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			in DecodeItemResult result,
+			DateTimeConversionMethod? specifiedMethod,
+			IDateTimeSerializationOptions options,
+			ref long position
+		)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			var deserialized =
+				Deserialize(
+					context.AsDeserializationOperationContext(),
+					ref reader,
+					result,
+					specifiedMethod,
+					options,
+					ref position
+				);
+			source.Advance(reader.Consumed);
+			return deserialized;
+		}
+
+		private static bool TryDecodeItem(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out DecodeItemResult result, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			context.Decoder.DecodeItem(ref reader, out result, out requestHint, context.CancellationToken);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+			return true;
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/CompatibilityAdapterAttribute.cs b/src/MsgPack.Serialization/Serialization/CompatibilityAdapterAttribute.cs
new file mode 100644
index 000000000..bdacf334e
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/CompatibilityAdapterAttribute.cs
@@ -0,0 +1,48 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+#warning TODO: CompatibilityAdapter support
+	/// <summary>
+	///		Marks that the type has special meaning for serialization process in previous version,
+	///		so it is required to specified adapter type to handle serialization and/or deserialization.
+	/// </summary>
+	/// <remarks>
+	///		Namely, this type decouples <c>I[Async][Un]packable</c> interfaces from this assembly.
+	/// </remarks>
+	[AttributeUsage(AttributeTargets.Interface)]
+	internal sealed class CompatibilityAdapterAttribute : Attribute
+	{
+		/// <summary>
+		///		Gets the adapter type which handle custom serialization and/or deserialization for the marked type.
+		/// </summary>
+		/// <value>
+		///		The <see cref="Type"/> of the adapter type which handle custom serialization and/or deserialization for the marked type.
+		/// </value>
+		public Type AdapterType { get; }
+
+		/// <summary>
+		///		Gets the kind of the adapter.
+		/// </summary>
+		/// <value>
+		///		The kind of the adapter.
+		/// </value>
+		public CompatibilityAdapterKind Kind { get; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="CompatibilityAdapterAttribute"/> object.
+		/// </summary>
+		/// <param name="kind"></param>
+		/// <param name="adapterType"></param>
+		public CompatibilityAdapterAttribute(CompatibilityAdapterKind kind, Type adapterType)
+		{
+			this.Kind = kind;
+			this.AdapterType = adapterType;
+		}
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/CompatibilityAdapterKind.cs b/src/MsgPack.Serialization/Serialization/CompatibilityAdapterKind.cs
new file mode 100644
index 000000000..dfbdd296f
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/CompatibilityAdapterKind.cs
@@ -0,0 +1,33 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Represents a type of the compatibility adapter.
+	/// </summary>
+	internal enum CompatibilityAdapterKind
+	{
+		/// <summary>
+		///		Synchronous serialization.
+		/// </summary>
+		Serialization,
+
+		/// <summary>
+		///		Synchronous deserialization.
+		/// </summary>
+		Deserialization,
+
+		/// <summary>
+		///		Asynchronous serialization.
+		/// </summary>
+		AsyncSerialization,
+
+		/// <summary>
+		///		Asynchronous deserialization.
+		/// </summary>
+		AsyncDeserialization
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/DateTimeSerializationOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/DateTimeSerializationOptionsBuilder.cs
new file mode 100644
index 000000000..527eae6e7
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DateTimeSerializationOptionsBuilder.cs
@@ -0,0 +1,204 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+#if FEATURE_COM_TYPES
+using System.Runtime.InteropServices.ComTypes;
+#endif // FEATURE_COM_TYPES
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Builder object to configure <see cref="DateTime"/> and similar types serialization behavior.
+	/// </summary>
+	public sealed class DateTimeSerializationOptionsBuilder
+	{
+		internal static DateTimeSerializationOptionsBuilder Default { get; } = new DateTimeSerializationOptionsBuilder();
+
+		private readonly HashSet<Type> _knownDateTimeLikeTypes;
+
+		internal ISet<Type> KnownDateTimeLikeTypeSet => this._knownDateTimeLikeTypes;
+
+		/// <summary>
+		///		Gets the collection which contains types which will be considered as date-time like type.
+		/// </summary>
+		/// <value>
+		///		The collection which contains types which will be considered as date-time like type.
+		/// </value>
+		public IEnumerable<Type> KnownDateTimeLikeTypes => this._knownDateTimeLikeTypes;
+
+		/// <summary>
+		///		Gets the default value of date time conversion method.
+		/// </summary>
+		/// <value>
+		///		The default value of date time conversion method.
+		///		Default is <c>null</c>, which means usage of the codec default format (<see cref="CodecFeatures.PreferredDateTimeConversionMethod"/>).
+		/// </value>
+		public DateTimeConversionMethod? DefaultDateTimeConversionMethod { get; private set; }
+
+		/// <summary>
+		///		Gets the precision of fraction portion on ISO 8601 date time string.
+		/// </summary>
+		/// <value>
+		///		The precision of fraction portion on ISO 8601 date time string as specified by this codec.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public int? Iso8601FractionOfSecondsPrecision { get; private set; }
+
+		/// <summary>
+		///		Gets the separator char for fraction portion.
+		/// </summary>
+		/// <value>
+		///		The separator char for fraction portion.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		public char? Iso8601DecimalMark { get; private set; }
+
+
+		/// <summary>
+		///		Initialized a new instance of <see cref="DateTimeSerializationOptionsBuilder"/> object.
+		/// </summary>
+		public DateTimeSerializationOptionsBuilder()
+		{
+			this._knownDateTimeLikeTypes =
+				new HashSet<Type>
+				{
+					typeof(DateTime),
+					typeof(DateTimeOffset),
+					typeof(Timestamp),
+#if FEATURE_COM_TYPES
+					typeof(FILETIME),
+#endif // FEATURE_COM_TYPES
+				};
+		}
+
+		/// <summary>
+		///		Adds the specified type as date-time like type.
+		/// </summary>
+		/// <param name="type">The <see cref="Type"/> to be treated as date-time like.</param>
+		/// <returns>This instance.</returns>
+		/// <remarks>
+		///		"Date-time like" types mean that a type which can be controlled its serialization behavior via <see cref="DateTimeConversionMethod"/> provider parameter.
+		///		To use the type as date-time like type, you should do following actions:
+		///		<list type="number">
+		///			<item>Register the type via this method.</item>
+		///			<item>Implements dedicated <see cref="IObjectSerializerProvider"/> for the type. You can use <see cref="DateTimeSerializerProvider"/> to implement provier easily.</item>
+		///			<item>Register dedicated <see cref="IObjectSerializerProvider"/> for the type via <see cref="SerializerProvider.RegisterDateTimeSerializerProvider"/>.</item>
+		///		</list>
+		///		Note that <see cref="SerializerProvider" /> treats following types and their nullable wrappers as date time like tyeps by default:
+		///		<list type="bullet">
+		///			<item><see cref="DateTime"/></item>
+		///			<item><see cref="DateTimeOffset"/></item>
+		///			<item><see cref="Timestamp"/></item>
+		///		</list>
+		///		You can override default behavior with <see cref="SerializerProvider.RegisterDateTimeSerializerProvider"/>.
+		/// </remarks>
+		public DateTimeSerializationOptionsBuilder AddDateTimeLikeType(Type type)
+		{
+			this._knownDateTimeLikeTypes.Add(Ensure.NotNull(type));
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates that the default value of date time conversion method to be codec default (<see cref="CodecFeatures.PreferredDateTimeConversionMethod"/>).
+		/// </summary>
+		/// <returns>This <see cref="DateTimeSerializationOptionsBuilder" /> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="DefaultDateTimeConversionMethod"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DateTimeSerializationOptionsBuilder UseCodecDefaultDateTimeConversionMethod()
+		{
+			this.DefaultDateTimeConversionMethod = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the default value of date time conversion method.
+		/// </summary>
+		/// <param name="value">
+		///		The default value of date time conversion method.
+		/// </param>
+		/// <returns>This <see cref="DateTimeSerializationOptionsBuilder" /> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="DefaultDateTimeConversionMethod"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DateTimeSerializationOptionsBuilder UseCustomDefaultDateTimeConversionMethod(DateTimeConversionMethod value)
+		{
+			this.DefaultDateTimeConversionMethod = Ensure.Defined(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the precision of ISO 8601 fraction of seconds portion.
+		/// </summary>
+		/// <param name="value">The precision.</param>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		<paramref name="value"/> is negative value or greater than 9.
+		/// </exception>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public DateTimeSerializationOptionsBuilder SetIso8601FractionOfSecondsPrecision(int value)
+		{
+			this.Iso8601FractionOfSecondsPrecision = Ensure.IsBetween(value, 0, 9);
+			return this;
+		}
+
+		/// <summary>
+		///		Resets the precision of ISO 8601 fraction of seconds portion.
+		/// </summary>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		public DateTimeSerializationOptionsBuilder ResetIso8601FractionOfSecondsPrecision()
+		{
+			this.Iso8601FractionOfSecondsPrecision = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the decimal separator of ISO 8601.
+		/// </summary>
+		/// <param name="value">The precision.</param>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentOutOfRangeException">
+		///		<paramref name="value"/> is not <c>,</c> nor <c>.</c>.
+		/// </exception>
+		public DateTimeSerializationOptionsBuilder SetIso8601DecimalMark(char value)
+		{
+			switch (value)
+			{
+				case ',':
+				case '.':
+				{
+					this.Iso8601DecimalMark = value;
+					break;
+				}
+				default:
+				{
+					Throw.InvalidIso8601DecimalMark(value);
+					break; // Never reaches
+				}
+			}
+
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the decimal separator of ISO 8601.
+		/// </summary>
+		/// <returns>This <see cref="CodecFeaturesBuilder"/> instance.</returns>
+		public DateTimeSerializationOptionsBuilder ResetIso8601DecimalMark()
+		{
+			this.Iso8601DecimalMark = null;
+			return this;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/DateTimeSerializerProvider.cs b/src/MsgPack.Serialization/Serialization/DateTimeSerializerProvider.cs
new file mode 100644
index 000000000..0cca19050
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DateTimeSerializerProvider.cs
@@ -0,0 +1,160 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using MsgPack.Codecs;
+using MsgPack.Serialization.BuiltinSerializers;
+using MsgPack.Serialization.DefaultSerializers;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Default <see cref="IObjectSerializerProvider"/> implementation for date time like types.
+	/// </summary>
+	public sealed class DateTimeSerializerProvider : IObjectSerializerProvider
+	{
+		/// <summary>
+		///		Represents input parameters for serializer factory delegate.
+		/// </summary>
+		public readonly struct SerializerInitializationParameters
+		{
+			/// <summary>
+			///		Gets the owner <see cref="SerializerProvider"/> for the new serializer.
+			/// </summary>
+			/// <value>
+			///		The owner <see cref="SerializerProvider"/> for the new serializer.
+			/// </value>
+			public SerializerProvider OwnerProvider { get; }
+
+			/// <summary>
+			///		Gets the <see cref="DateTimeConversionMethod"/> which the new serializer should handle to.
+			/// </summary>
+			/// <value>
+			///		The <see cref="DateTimeConversionMethod"/> which the new serializer should handle to.
+			///		Or <c>null</c> when the serializer should handle with the <see cref="DefaultMethodGetter"/> delegate.
+			/// </value>
+			public DateTimeConversionMethod? TargetMethod { get; }
+
+			/// <summary>
+			///		Gets the delegate which determine final <see cref="DateTimeConversionMethod"/> with <see cref="FormatEncoderOptions.CodecFeatures"/>.
+			/// </summary>
+			/// <value>
+			///		The delegate which determine final <see cref="DateTimeConversionMethod"/> with <see cref="FormatEncoderOptions.CodecFeatures"/>.
+			/// </value>
+			public Func<CodecFeatures, DateTimeConversionMethod> DefaultMethodGetter { get; }
+
+			internal SerializerInitializationParameters(
+				SerializerProvider ownerProvider,
+				DateTimeConversionMethod? targetMethod,
+				Func<CodecFeatures, DateTimeConversionMethod> defaultMethodGetter
+			)
+			{
+				this.OwnerProvider = ownerProvider;
+				this.TargetMethod = targetMethod;
+				this.DefaultMethodGetter = defaultMethodGetter;
+			}
+		}
+
+		private readonly Type _targetType;
+#pragma warning disable CS8714
+		private readonly IReadOnlyDictionary<DateTimeConversionMethod?, ObjectSerializer> _serializers;
+#pragma warning restore CS8714
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="DateTimeSerializerProvider"/> object.
+		/// </summary>
+		/// <param name="targetType">
+		///		The target type which this object should handle to.
+		///	</param>
+		/// <param name="serializerProvider">
+		///		The <see cref="SerializerProvider"/> which will be owner of serializers created by <paramref name="serializerFactory"/>.
+		///	</param>
+		/// <param name="serializerFactory">
+		///		The delegate which generates real <see cref="ObjectSerializer"/> which handle <paramref name="targetType"/> with specific <see cref="DateTimeConversionMethod"/>.
+		/// </param>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="targetType"/> is <c>null</c>.
+		///		Or, <paramref name="serializerProvider"/> is <c>null</c>.
+		///		Or, <paramref name="serializerFactory"/> is <c>null</c>.
+		/// </exception>
+		public DateTimeSerializerProvider(
+			Type targetType,
+			SerializerProvider serializerProvider,
+			Func<SerializerInitializationParameters, ObjectSerializer> serializerFactory
+		)
+		{
+			this._targetType = Ensure.NotNull(targetType);
+			Func<CodecFeatures, DateTimeConversionMethod> defaultMethodGetter =
+				Ensure.NotNull(serializerProvider).SerializerGenerationOptions.DateTimeOptions.GetDefaultDateTimeConversionMethod;
+			Ensure.NotNull(serializerFactory);
+
+#pragma warning disable CS8714
+			void AddSerializer(IDictionary<DateTimeConversionMethod?, ObjectSerializer> dictionary, DateTimeConversionMethod? method)
+#pragma warning restore CS8714
+				=> dictionary.Add(
+					method,
+					serializerFactory(new SerializerInitializationParameters(serializerProvider, method, defaultMethodGetter))
+				);
+
+			var serializers =
+#pragma warning disable CS8714
+				new Dictionary<DateTimeConversionMethod?, ObjectSerializer>(4);
+#pragma warning restore CS8714
+			AddSerializer(serializers, null);
+			AddSerializer(serializers, DateTimeConversionMethod.Native);
+			AddSerializer(serializers, DateTimeConversionMethod.Timestamp);
+			AddSerializer(serializers, DateTimeConversionMethod.UnixEpoc);
+			this._serializers = serializers;
+		}
+
+		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
+		{
+			if (!Ensure.NotNull(targetType).IsAssignableFrom(this._targetType))
+			{
+				Throw.IncompatibleTargetType(this._targetType, targetType);
+			}
+
+			DateTimeConversionMethod? method = default;
+			if (providerParameter is BoxedDateTimeConversionMethod boxed)
+			{
+				method = boxed.Value;
+			}
+			else if (providerParameter is DateTimeConversionMethod unboxed)
+			{
+				method = unboxed;
+			}
+
+			return this._serializers[method];
+		}
+
+		internal static DateTimeSerializerProvider CreateDateTime(SerializerProvider provider)
+			=> new DateTimeSerializerProvider(
+				typeof(DateTime),
+				provider,
+				p => new DateTimeObjectSerializer(p.OwnerProvider, p.TargetMethod)
+			);
+
+		internal static DateTimeSerializerProvider CreateDateTimeOffset(SerializerProvider provider)
+			=> new DateTimeSerializerProvider(
+				typeof(DateTimeOffset),
+				provider,
+				p => new DateTimeOffsetObjectSerializer(p.OwnerProvider, p.TargetMethod)
+			);
+
+		internal static DateTimeSerializerProvider CreateTimestamp(SerializerProvider provider)
+			=> new DateTimeSerializerProvider(
+				typeof(Timestamp),
+				provider,
+				p => new TimestampObjectSerializer(p.OwnerProvider, p.TargetMethod)
+			);
+
+		internal static DateTimeSerializerProvider CreateFileTime(SerializerProvider provider)
+			=> new DateTimeSerializerProvider(
+				typeof(Timestamp),
+				provider,
+				p => new FileTimeOffsetObjectSerializer(p.OwnerProvider, p.TargetMethod)
+			);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/DefaultConcreteTypeRepositoryBuilder.cs b/src/MsgPack.Serialization/Serialization/DefaultConcreteTypeRepositoryBuilder.cs
new file mode 100644
index 000000000..83f660759
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DefaultConcreteTypeRepositoryBuilder.cs
@@ -0,0 +1,216 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Builder object to configure default concrete types for abstract collection types on deserialization.
+	/// </summary>
+	public sealed class DefaultConcreteTypeRepositoryBuilder
+	{
+		internal TypeKeyRepository DefaultCollectionTypes { get; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="DefaultConcreteTypeRepositoryBuilder"/> object.
+		/// </summary>
+		/// <remarks>
+		///		This constructor internally registers default type mapping for known collection types.
+		/// </remarks>
+		public DefaultConcreteTypeRepositoryBuilder()
+		{
+			this.DefaultCollectionTypes =
+				new TypeKeyRepository(
+					new Dictionary<RuntimeTypeHandle, object>(
+#if !FEATURE_ISET && !FEATURE_READ_ONLY_COLLECTION
+						8
+#elif !FEATURE_READ_ONLY_COLLECTION
+						9
+#else
+						12
+#endif
+					)
+					{
+						{ typeof(IEnumerable<>).TypeHandle, typeof(List<>) },
+						{ typeof(ICollection<>).TypeHandle, typeof(List<>) },
+						{ typeof(IList<>).TypeHandle, typeof(List<>) },
+						{ typeof(IDictionary<,>).TypeHandle, typeof(Dictionary<,>) },
+						{ typeof(IEnumerable).TypeHandle, typeof(List<MessagePackObject>) },
+						{ typeof(ICollection).TypeHandle, typeof(List<MessagePackObject>) },
+						{ typeof(IList).TypeHandle, typeof(List<MessagePackObject>) },
+						{ typeof(IDictionary).TypeHandle, typeof(MessagePackObjectDictionary) },
+#if FEATURE_ISET
+						{ typeof(ISet<>).TypeHandle, typeof(HashSet<>) },
+#if FEATURE_READ_ONLY_COLLECTION
+						{ typeof(IReadOnlyCollection<> ).TypeHandle, typeof(List<>) },
+						{ typeof(IReadOnlyList<>).TypeHandle, typeof(List<>) },
+						{ typeof(IReadOnlyDictionary<,>).TypeHandle, typeof(Dictionary<,>) },
+#endif // FEATURE_READ_ONLY_COLLECTION
+#endif // FEATURE_ISET
+					}
+				);
+		}
+
+		internal DefaultConcreteTypeRepositoryBuilder(TypeKeyRepository existing)
+		{
+			this.DefaultCollectionTypes = new TypeKeyRepository(existing);
+		}
+
+		internal ImmutableDefaultConcreteTypeRepository Build()
+			=> new ImmutableDefaultConcreteTypeRepository(this.DefaultCollectionTypes.GetClonedTable());
+
+		/// <summary>
+		///		Registers the default type of the collection.
+		/// </summary>
+		/// <param name="abstractCollectionType">Type of the abstract collection.</param>
+		/// <param name="defaultCollectionType">Default concrete type of the <paramref name="abstractCollectionType"/>.</param>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="abstractCollectionType"/> is <c>null</c>.
+		///		Or <paramref name="defaultCollectionType"/> is <c>null</c>.
+		/// </exception>
+		/// <exception cref="System.ArgumentException">
+		///		<paramref name="abstractCollectionType"/> is not collection type.
+		///		Or <paramref name="defaultCollectionType"/> is abstract class or interface.
+		///		Or <paramref name="defaultCollectionType"/> is open generic type but <paramref name="abstractCollectionType"/> is closed generic type.
+		///		Or <paramref name="defaultCollectionType"/> is closed generic type but <paramref name="abstractCollectionType"/> is open generic type.
+		///		Or <paramref name="defaultCollectionType"/> does not have same arity for <paramref name="abstractCollectionType"/>.
+		///		Or <paramref name="defaultCollectionType"/> is not assignable to <paramref name="abstractCollectionType"/>
+		///		or the constructed type from <paramref name="defaultCollectionType"/> will not be assignable to the constructed type from <paramref name="abstractCollectionType"/>.
+		/// </exception>
+		/// <remarks>
+		///		If you want to overwrite default type for collection interfaces, you can use this method.
+		///		Note that this method only supports collection interface, that is subtype of the <see cref="IEnumerable"/> interface.
+		///		<note>
+		///			If you register invalid type for <paramref name="defaultCollectionType"/>, then runtime exception will be occurred.
+		///			For example, you register <see cref="IEnumerable{T}"/> of <see cref="Char"/> and <see cref="String"/> pair, but it will cause runtime error.
+		///		</note>
+		/// </remarks>
+		/// <seealso cref="Get"/>
+		public void Register(Type abstractCollectionType, Type defaultCollectionType)
+		{
+
+			if (abstractCollectionType == null)
+			{
+				throw new ArgumentNullException("abstractCollectionType");
+			}
+
+			if (defaultCollectionType == null)
+			{
+				throw new ArgumentNullException("defaultCollectionType");
+			}
+
+			// Use GetIntegerfaces() in addition to IsAssignableFrom because of open generic type support.
+			if (!abstractCollectionType.GetInterfaces().Contains(typeof(IEnumerable)))
+			{
+				throw new ArgumentException(
+					String.Format(CultureInfo.CurrentCulture, "The type '{0}' is not collection.", abstractCollectionType),
+					"abstractCollectionType");
+			}
+
+			if (abstractCollectionType.GetIsGenericTypeDefinition())
+			{
+				if (!defaultCollectionType.GetIsGenericTypeDefinition())
+				{
+					throw new ArgumentException(
+						String.Format(
+							CultureInfo.CurrentCulture,
+							"The closed generic type '{1}' cannot be assigned to open generic type '{0}'.",
+							abstractCollectionType,
+							defaultCollectionType),
+						"defaultCollectionType");
+				}
+
+				if (abstractCollectionType.GetGenericTypeParameters().Length !=
+					defaultCollectionType.GetGenericTypeParameters().Length)
+				{
+					throw new ArgumentException(
+						String.Format(
+							CultureInfo.CurrentCulture,
+							"The default generic collection type '{1}' does not have same arity for abstract generic collection type '{0}'.",
+							abstractCollectionType,
+							defaultCollectionType),
+						"defaultCollectionType");
+				}
+			}
+			else if (defaultCollectionType.GetIsGenericTypeDefinition())
+			{
+				throw new ArgumentException(
+					String.Format(
+						CultureInfo.CurrentCulture,
+						"The open generic type '{1}' cannot be assigned to closed generic type '{0}'.",
+						abstractCollectionType,
+						defaultCollectionType),
+					"defaultCollectionType");
+			}
+
+			if (defaultCollectionType.GetIsAbstract() || defaultCollectionType.GetIsInterface())
+			{
+				throw new ArgumentException(
+					String.Format(CultureInfo.CurrentCulture, "The defaultCollectionType cannot be abstract class nor interface. The type '{0}' is abstract type.", defaultCollectionType),
+					"defaultCollectionType");
+			}
+
+			// Use GetIntegerfaces() and BaseType instead of IsAssignableFrom because of open generic type support.
+			if (!abstractCollectionType.IsAssignableFrom(defaultCollectionType)
+				 && abstractCollectionType.GetIsGenericTypeDefinition()
+				 && !defaultCollectionType
+						 .GetInterfaces()
+						 .Select(t => (t.GetIsGenericType() && !t.GetIsGenericTypeDefinition()) ? t.GetGenericTypeDefinition() : t)
+						 .Contains(abstractCollectionType)
+				 && !IsAnscestorType(abstractCollectionType, defaultCollectionType))
+			{
+				throw new ArgumentException(
+					String.Format(
+						CultureInfo.CurrentCulture,
+						"The type '{1}' is not assignable to '{0}'.",
+						abstractCollectionType,
+						defaultCollectionType),
+					"defaultCollectionType");
+			}
+
+			this.DefaultCollectionTypes.Register(abstractCollectionType, defaultCollectionType, null, null, SerializerRegistrationOptions.AllowOverride);
+		}
+
+		private static bool IsAnscestorType(Type mayBeAncestor, Type mayBeDescendant)
+		{
+			for (var type = mayBeDescendant; type != null; type = type.GetBaseType())
+			{
+				if (type == mayBeAncestor)
+				{
+					return true;
+				}
+
+				if (type.GetIsGenericType() && type.GetGenericTypeDefinition() == mayBeAncestor)
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/// <summary>
+		///		Unregisters the default type of the collection.
+		/// </summary>
+		/// <param name="abstractCollectionType">Type of the abstract collection.</param>
+		/// <returns>
+		///		<c>true</c> if default collection type is removed successfully;
+		///		otherwise, <c>false</c>.
+		/// </returns>
+		public bool Unregister(Type abstractCollectionType)
+		{
+			if (abstractCollectionType == null)
+			{
+				return false;
+			}
+
+			return this.DefaultCollectionTypes.Unregister(abstractCollectionType);
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/DefaultMessagePackAttributeCompatibilityProviders.cs b/src/MsgPack.Serialization/Serialization/DefaultMessagePackAttributeCompatibilityProviders.cs
new file mode 100644
index 000000000..a1d46ff45
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DefaultMessagePackAttributeCompatibilityProviders.cs
@@ -0,0 +1,111 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines default provider logic for <see cref="MessagePackMemberAttribute"/> compatibility.
+	/// </summary>
+	public static class DefaultMessagePackAttributeCompatibilityProviders
+	{
+		/// <summary>
+		///		Gets a delegate for the logic which provides <see cref="MessagePackMemberAttributeData"/> or <c>null</c> from specified attributes.
+		/// </summary>
+		/// <value>
+		///		A delegate for the logic which provides <see cref="MessagePackMemberAttributeData"/> or <c>null</c> from specified attributes.
+		/// </value>
+		/// <remarks>
+		///		The logic provides compatiblity for <c>System.Runtime.Serialization.DataMemberAttribute</c>
+		///		only if the type is qualified with <c>System.Runtime.Serialization.DataContractAttribute</c>.
+		/// </remarks>
+		public static Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?> DefaultMessagePackMemberAttributeCompatibilityProvider { get; } = ProvideDefaultMessagePackMemberAttributeCompatibility;
+
+		/// <summary>
+		///		Gets a delegate for the logic which provides <see cref="MessagePackIgnoreAttributeData"/> or <c>null</c> from specified attributes.
+		/// </summary>
+		/// <value>
+		///		A delegate for the logic which provides <see cref="MessagePackIgnoreAttributeData"/> or <c>null</c> from specified attributes.
+		/// </value>
+		/// <remarks>
+		///		The logic always returns <c>null</c>.
+		/// </remarks>
+		public static Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackIgnoreAttributeData?> DefaultMessagePackIgnoreAttributeCompatibilityProvider { get; } = ProvideDefaultMessagePackIgnoreAttributeCompatibility;
+
+		/// <summary>
+		///		Provides <see cref="MessagePackMemberAttributeData"/> from specified attributes.
+		/// </summary>
+		/// <param name="typeAttributes">Attributes which qualify a type which declares current target member.</param>
+		/// <param name="memberAttributes">Attribute which qualify current target member.</param>
+		/// <returns>
+		///		Compatible <see cref="MessagePackMemberAttributeData"/>. <c>null</c> if no compatible attributes were found.
+		/// </returns>
+		/// <remarks>
+		///		This logic provides compatiblity for <c>System.Runtime.Serialization.DataMemberAttribute</c>
+		///		only if the type is qualified with <c>System.Runtime.Serialization.DataContractAttribute</c>.
+		/// </remarks>
+		private static MessagePackMemberAttributeData? ProvideDefaultMessagePackMemberAttributeCompatibility(
+			IEnumerable<CustomAttributeData> typeAttributes,
+			IEnumerable<CustomAttributeData> memberAttributes
+		)
+		{
+			if (!typeAttributes.Any(a => a.GetAttributeType().FullName == "System.Runtime.Serialization.DataContractAttribute"))
+			{
+				return null;
+			}
+
+			var dataMemberAttribute =
+				memberAttributes
+				.FirstOrDefault(a =>
+					a.GetAttributeType()
+					.FullName == "System.Runtime.Serialization.DataMemberAttribute"
+				);
+			if (dataMemberAttribute == null)
+			{
+				return null;
+			}
+
+			var name = default(string?);
+			var order = default(int?);
+			foreach (var namedArgument in dataMemberAttribute.GetNamedArguments())
+			{
+				var memberName = namedArgument.GetMemberName();
+				if (memberName == "Name")
+				{
+					name = (string?)namedArgument.GetTypedValue().Value;
+				}
+				else if (memberName == "Order")
+				{
+					order = (int?)namedArgument.GetTypedValue().Value;
+				}
+			}
+
+			return new MessagePackMemberAttributeData(order < 0 ? null : order, name);
+		}
+
+		/// <summary>
+		///		Provides <see cref="MessagePackIgnoreAttributeData"/> from specified attributes.
+		/// </summary>
+		/// <param name="typeAttributes">Attributes which qualify a type which declares current target member.</param>
+		/// <param name="memberAttributes">Attribute which qualify current target member.</param>
+		/// <returns>
+		///		Always <c>null</c>.
+		/// </returns>
+		/// <remarks>
+		///		This logic provides compatiblity for <c>System.Runtime.Serialization.DataMemberAttribute</c>
+		///		only if the type is qualified with <c>System.Runtime.Serialization.DataContractAttribute</c>.
+		/// </remarks>
+		private static MessagePackIgnoreAttributeData? ProvideDefaultMessagePackIgnoreAttributeCompatibility(
+			IEnumerable<CustomAttributeData> typeAttributes,
+			IEnumerable<CustomAttributeData> memberAttributes
+		) => memberAttributes.Any(
+				a => a.AttributeType.FullName == "System.Runtime.Serialization.IgnoreDataMemberAttribute") ?
+				default(MessagePackIgnoreAttributeData) : 
+				default(MessagePackIgnoreAttributeData?);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/DefaultSerializer`1.cs b/src/MsgPack.Serialization/Serialization/DefaultSerializer`1.cs
new file mode 100644
index 000000000..6549ef4ab
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DefaultSerializer`1.cs
@@ -0,0 +1,25 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Default implementation of <see cref="Serializer{T}"/>.
+	/// </summary>
+	/// <typeparam name="T">The target type.</typeparam>
+	internal sealed class DefaultSerializer<T> : Serializer<T>
+	{
+		public DefaultSerializer(
+			CodecProvider codecProvider,
+			ObjectSerializer<T> underlying,
+			SerializationOptions serializationOptions,
+			DeserializationOptions deserializationOptions
+		)
+			: base(codecProvider, underlying, serializationOptions, deserializationOptions)
+		{
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.cs b/src/MsgPack.Serialization/Serialization/DeserializationOperationContext.cs
similarity index 96%
rename from src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.cs
rename to src/MsgPack.Serialization/Serialization/DeserializationOperationContext.cs
index 6e95b0627..273527511 100644
--- a/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.cs
+++ b/src/MsgPack.Serialization/Serialization/DeserializationOperationContext.cs
@@ -20,7 +20,7 @@ public struct DeserializationOperationContext
 	{
 		public FormatDecoder Decoder { get; }
 		public DeserializationOptions Options { get; }
-		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public Encoding? StringEncoding => this.Options.DefaultStringEncoding;
 		public ArrayPool<byte> ByteBufferPool => this.Options.ByteBufferPool;
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
diff --git a/src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.tt b/src/MsgPack.Serialization/Serialization/DeserializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/DeserializationOperationContext.tt
rename to src/MsgPack.Serialization/Serialization/DeserializationOperationContext.tt
diff --git a/src/MsgPack.Serialization/Serialization/DeserializationOptions.cs b/src/MsgPack.Serialization/Serialization/DeserializationOptions.cs
new file mode 100644
index 000000000..ed0d7b8af
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DeserializationOptions.cs
@@ -0,0 +1,90 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Text;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines each deserialization operations level options. This object is immutable.
+	/// </summary>
+	/// <seealso cref="DeserializationOptionsBuilder"/>
+	public sealed class DeserializationOptions
+	{
+		public static DeserializationOptions Default { get; } = new DeserializationOptionsBuilder().Create();
+
+		/// <summary>
+		///		Gets the allowed maximum length of the serialized array.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum length of the serialized array. Default is <c>1,048,576</c> (<c>1Mi</c>).
+		/// </value>
+		public int MaxArrayLength { get; }
+
+		/// <summary>
+		///		Gets the allowed maximum count of the serialized map entries.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum count of the serialized map entries. Default is <c>1,048,576</c> (<c>1Mi</c>).
+		/// </value>
+		public int MaxMapCount { get; }
+
+		/// <summary>
+		///		Gets the allowed maximum length of each serialized map keys.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum length of each serialized map keys. Default is <c>256</c>.
+		/// </value>
+		public int MaxPropertyKeyLength { get; }
+
+		/// <summary>
+		///		Gets the allowed maximum depth of the serialized object tree.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum depth of the serialized object tree. Default is <c>100</c>.
+		/// </value>
+		public int MaxDepth { get; }
+
+		/// <summary>
+		///		Gets the default string encoding for string members or map keys which are not specified explicitly.
+		/// </summary>
+		/// <value>
+		///		The default string encoding for string members or map keys which are not specified explicitly.
+		///		Default value is <c>null</c>, which means using default encoding of underlying codec.
+		/// </value>
+		public Encoding? DefaultStringEncoding { get; }
+
+		/// <summary>
+		///		Gets the <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.
+		/// </summary>
+		/// <value>
+		///		The <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.
+		/// </value>
+		public ArrayPool<byte> ByteBufferPool { get; }
+
+		/// <summary>
+		///		Gets the value which indicates whether the buffer from <see cref="ByteBufferPool"/> should be cleared on return.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the buffer should be zero-cleared; <c>false</c>, otherwise. The default is <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		If <c>false</c>, a malicious serializer can snoof buffer contents, so it might be security vulnerability.
+		///		If <c>true</c>, security is improved, but significant performance hit may be occurred for large buffer.
+		/// </remarks>
+		public bool ClearsByteBufferOnReturn { get; }
+
+		internal DeserializationOptions(DeserializationOptionsBuilder builder)
+		{
+			this.MaxArrayLength = builder.MaxArrayLength;
+			this.MaxMapCount = builder.MaxMapCount;
+			this.MaxPropertyKeyLength = builder.MaxPropertyKeyLength;
+			this.MaxDepth = builder.MaxDepth;
+			this.DefaultStringEncoding = builder.DefaultStringEncoding;
+			this.ByteBufferPool = builder.ByteBufferPool ?? ArrayPool<byte>.Shared;
+			this.ClearsByteBufferOnReturn = builder.ClearsByteBufferOnReturn;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/DeserializationOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/DeserializationOptionsBuilder.cs
new file mode 100644
index 000000000..cd8a10458
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DeserializationOptionsBuilder.cs
@@ -0,0 +1,278 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		A builder object for <see cref="DeserializationOptions"/> which defines options for each deserialization operations.
+	/// </summary>
+	/// <seealso cref="DeserializationOptions"/>
+	public sealed class DeserializationOptionsBuilder
+	{
+		/// <summary>
+		///		Gets the allowed maximum length of the serialized array.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum length of the serialized array. Default is <c>1,048,576</c> (<c>1Mi</c>).
+		/// </value>
+		public int MaxArrayLength { get; private set; } = OptionsDefaults.MaxArrayLength;
+
+		/// <summary>
+		///		Gets the allowed maximum count of the serialized map entries.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum count of the serialized map entries. Default is <c>1,048,576</c> (<c>1Mi</c>).
+		/// </value>
+		public int MaxMapCount { get; private set; } = OptionsDefaults.MaxMapCount;
+
+		/// <summary>
+		///		Gets the allowed maximum length of each serialized map keys.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum length of each serialized map keys. Default is <c>256</c>.
+		/// </value>
+		public int MaxPropertyKeyLength { get; private set; } = OptionsDefaults.MaxPropertyKeyLength;
+
+		/// <summary>
+		///		Gets the allowed maximum depth of the serialized object tree.
+		/// </summary>
+		/// <value>
+		///		The allowed maximum depth of the serialized object tree. Default is <c>100</c>.
+		/// </value>
+		public int MaxDepth { get; private set; } = OptionsDefaults.MaxDepth;
+
+		/// <summary>
+		///		Gets the default string encoding for string members or map keys which are not specified explicitly.
+		/// </summary>
+		/// <value>
+		///		The default string encoding for string members or map keys which are not specified explicitly.
+		///		Default value is <c>null</c>, which means using default encoding of underlying codec.
+		/// </value>
+		public Encoding? DefaultStringEncoding { get; private set; }
+
+		/// <summary>
+		///		Gets the <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.
+		/// </summary>
+		/// <value>
+		///		The <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.
+		///		<c>null</c> means usage of the default pool which is defined by serialization runtime implementation.
+		///		Note that the pool will be shared all serializers and codecs.
+		/// </value>
+		public ArrayPool<byte>? ByteBufferPool { get; private set; }
+
+		/// <summary>
+		///		Gets the value which indicates whether the buffer from <see cref="ByteBufferPool"/> should be cleared on return.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the buffer should be zero-cleared; <c>false</c>, otherwise. The default is <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		If <c>false</c>, a malicious serializer can snoof buffer contents, so it might be security vulnerability.
+		///		If <c>true</c>, security is improved, but significant performance hit may be occurred for large buffer.
+		/// </remarks>
+		public bool ClearsByteBufferOnReturn { get; private set; } = OptionsDefaults.ClearsBufferOnReturn;
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="DeserializationOptionsBuilder"/> object.
+		/// </summary>
+		public DeserializationOptionsBuilder() { }
+
+		/// <summary>
+		///		Creates a new instance of <see cref="DeserializationOptions"/> object from current state of this instance.
+		/// </summary>
+		/// <returns>A new instance of <see cref="DeserializationOptions"/> object.</returns>
+		public DeserializationOptions Create()
+			=> new DeserializationOptions(this.MaxArrayLength, this.MaxMapCount, this.MaxPropertyKeyLength, this.MaxDepth, this.DefaultStringEncoding, this.ByteBufferPool ?? ArrayPool<byte>.Shared, this.ClearsByteBufferOnReturn);
+
+		/// <summary>
+		///		Indicates the allowed maximum length of the serialized array to the default value.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="MaxDepth"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseDefaultMaxArrayLength()
+			=> this.UseMaxArrayLength(OptionsDefaults.MaxArrayLength);
+
+		/// <summary>
+		///		Sets the allowed maximum length of the serialized array.
+		/// </summary>
+		/// <param name="value">A value to be set.</param>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="value"/> is less than or equal to <c>0</c>, or exceeds <c>0x7FEFFFFF</c>.
+		/// </exception>
+		public DeserializationOptionsBuilder UseMaxArrayLength(int value)
+		{
+			this.MaxArrayLength = Ensure.IsBetween(value, 0, OptionsDefaults.MaxMultiByteCollectionLength);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the allowed maximum count of the serialized map entries to the default value.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="MaxDepth"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseDefaultMaxMapCount()
+			=> this.UseMaxMapCount(OptionsDefaults.MaxMapCount);
+
+		/// <summary>
+		///		Sets the allowed maximum count of the serialized map entries.
+		/// </summary>
+		/// <param name="value">A value to be set.</param>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="value"/> is less than or equal to <c>0</c>, or exceeds <c>0x7FEFFFFF</c>.
+		/// </exception>
+		public DeserializationOptionsBuilder UseMaxMapCount(int value)
+		{
+			this.MaxMapCount = Ensure.IsBetween(value, 0, OptionsDefaults.MaxMultiByteCollectionLength);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the allowed maximum length of each serialized map keys to the default value.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="MaxDepth"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseDefaultMaxPropertyKeyLength()
+			=> this.UseMaxPropertyKeyLength(OptionsDefaults.MaxPropertyKeyLength);
+
+		/// <summary>
+		///		Sets the allowed maximum length of each serialized map keys.
+		/// </summary>
+		/// <param name="value">A value to be set.</param>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="value"/> is less than or equal to <c>0</c>, or exceeds <c>0x7FEFFFFF</c>.
+		/// </exception>
+		public DeserializationOptionsBuilder UseMaxPropertyKeyLength(int value)
+		{
+			this.MaxPropertyKeyLength = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the allowed maximum depth of serialized object tree to the default value.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="MaxDepth"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseDefaultMaxDepth()
+			=> this.UseMaxDepth(OptionsDefaults.MaxDepth);
+
+		/// <summary>
+		///		Sets the allowed maximum depth of serialized object tree.
+		/// </summary>
+		/// <param name="value">A value to be set.</param>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="value"/> is less than or equal to <c>0</c>, or exceeds <c>0x7FEFFFFF</c>.
+		/// </exception>
+		public DeserializationOptionsBuilder UseMaxDepth(int value)
+		{
+			this.MaxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength); ;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the default string encoding for string members or map keys to use default encoding of the codec.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="DefaultStringEncoding"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseCodecDefaultStringEncoding()
+		{
+			this.DefaultStringEncoding = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the default string encoding for string members or map keys which are not specified explicitly.
+		/// </summary>
+		/// <param name="value">An <see cref="Encoding"/> to use encode/decode string value.</param>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException"><paramref name="value"/> is <c>null</c>.</exception>
+		/// <remarks>
+		///		This method should be called only when you needs to interoperability with system which uses non-default encoding for the codec.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseCustomDefaultStringEncoding(Encoding value)
+		{
+			this.DefaultStringEncoding = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the default <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="ByteBufferPool"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseDefaultByteBufferPool()
+		{
+			this.ByteBufferPool = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.
+		/// </summary>
+		/// <param name="value">The <see cref="ArrayPool{T}"/> of <see cref="System.Byte"/> which will be used as buffer for codec.</param>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException"><paramref name="value"/> is <c>null</c>.</exception>
+		/// <remarks>
+		///		Note that the pool will be shared all serializers and codecs.
+		/// </remarks>
+		public DeserializationOptionsBuilder UseCustomByteBufferPool(ArrayPool<byte> value)
+		{
+			this.ByteBufferPool = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the buffer from <see cref="ByteBufferPool"/> should be cleared on return.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method prevents that a malicious serializer can snoof buffer contents, so it might be security vulnerability.
+		///		However, significant performance hit may be occurred for large buffer.
+		/// </remarks>
+		public DeserializationOptionsBuilder WithClearingByteBufferOnReturn()
+		{
+			this.ClearsByteBufferOnReturn = true;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the buffer from <see cref="ByteBufferPool"/> should NOT be cleared on return.
+		/// </summary>
+		/// <returns>This <see cref="DeserializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="ClearsByteBufferOnReturn"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DeserializationOptionsBuilder WithoutClearingByteBufferOnReturn()
+		{
+			this.ClearsByteBufferOnReturn = false;
+			return this;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Dianostic.cs b/src/MsgPack.Serialization/Serialization/Dianostic.cs
new file mode 100644
index 000000000..9dd431476
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Dianostic.cs
@@ -0,0 +1,163 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System.Diagnostics;
+
+namespace MsgPack.Serialization
+{
+	internal static class Diagnostic
+	{
+		public static class General
+		{
+			private static readonly DiagnosticSource Source = new DiagnosticListener("MsgPack.Serialization");
+
+			public static bool IsEnabled(string key)
+				=> Source.IsEnabled(key);
+
+			public static class Keys
+			{
+				public const string AotError = "AotError";
+				public const string HoistUpInnerExceptionFailed = "HoistUpInnerExceptionFailed";
+			}
+
+			public static void AotError(object data)
+				=> Source.Write(Keys.AotError, data);
+
+			public static void HoistUpInnerExceptionFailed(object data)
+				=> Source.Write(Keys.HoistUpInnerExceptionFailed, data);
+		}
+
+		public static class GeneratorTrace
+		{
+			private static readonly DiagnosticSource Source = new DiagnosticListener("MsgPack.Serialization.Generators.Trace");
+
+			public static bool IsEnabled(string key)
+				=> Source.IsEnabled(key);
+
+			public static class Keys
+			{
+				public const string DetectedAsDeserializable = "DetectedAsDeserializable";
+				public const string DeserializationConstructorFound = "DeserializationConstructorFound";
+				public const string SkipStaticMember = "SkipStaticMember";
+				public const string SkipIndexer = "SkipIndexer";
+				public const string SkipSetOnlyProperty = "SkipSetOnlyProperty";
+				public const string SkipMemberDueToAccessibility = "SkipMemberDueToAccessibility";
+				public const string UseCollectionAddForReadOnlyMember = "UseCollectionAddForReadOnlyMember";
+				public const string UseConstructorForMemberAccessDueToAccessibility = "UseConstructorForMemberAccessDueToAccessibility";
+				public const string UseConstructorForMemberAccessDueToReadOnly = "UseConstructorForMemberAccessDueToReadOnly";
+				public const string UseDelegateForMemberAccess = "UseDelegateForMemberAccess";
+				public const string UseDirectMemberAccessDueToPublic = "UseDirectMemberAccessDueToPublic";
+				public const string UseDirectMemberAccessDueToInternalsVisibleTo = "UseDirectMemberAccessDueToInternalsVisibleTo";
+				public const string UseIgnoreAccessChecksToAttributeForMemberAccess = "UseIgnoreAccessChecksToAttributeForMemberAccess";
+				public const string UseReflectionMemberAccess = "UseReflectionMemberAccess";
+				public const string WillBeAsymmetricDueToReadOnlyMember = "WillBeAsymmetricDueToReadOnlyMember";
+			}
+
+			public static void DetectedAsDeserializable(object data)
+				=> Source.Write(Keys.DetectedAsDeserializable, data);
+
+			public static void DeserializationConstructorFound(object data)
+				=> Source.Write(Keys.DeserializationConstructorFound, data);
+
+			public static void SkipStaticMember(object data)
+				=> Source.Write(Keys.SkipStaticMember, data);
+
+			public static void SkipIndexer(object data)
+				=> Source.Write(Keys.SkipIndexer, data);
+
+			public static void SkipSetOnlyProperty(object data)
+				=> Source.Write(Keys.SkipSetOnlyProperty, data);
+
+			public static void SkipMemberDueToAccessibility(object data)
+				=> Source.Write(Keys.SkipMemberDueToAccessibility, data);
+
+			public static void UseCollectionAddForReadOnlyMember(object data)
+				=> Source.Write(Keys.UseCollectionAddForReadOnlyMember, data);
+
+			public static void UseConstructorForMemberAccessDueToAccessibility(object data)
+				=> Source.Write(Keys.UseConstructorForMemberAccessDueToAccessibility, data);
+
+			public static void UseConstructorForMemberAccessDueToReadOnly(object data)
+				=> Source.Write(Keys.UseConstructorForMemberAccessDueToReadOnly, data);
+
+			public static void UseDelegateForMemberAccess(object data)
+				=> Source.Write(Keys.UseDelegateForMemberAccess, data);
+
+			public static void UseDirectMemberAccessDueToPublic(object data)
+				=> Source.Write(Keys.UseDirectMemberAccessDueToPublic, data);
+
+			public static void UseDirectMemberAccessDueToInternalsVisibleTo(object data)
+				=> Source.Write(Keys.UseDirectMemberAccessDueToInternalsVisibleTo, data);
+
+			public static void UseIgnoreAccessChecksToAttributeForMemberAccess(object data)
+				=> Source.Write(Keys.UseIgnoreAccessChecksToAttributeForMemberAccess, data);
+
+			public static void UseReflectionMemberAccess(object data)
+				=> Source.Write(Keys.UseReflectionMemberAccess, data);
+
+			public static void WillBeAsymmetricDueToReadOnlyMember(object data)
+				=> Source.Write(Keys.WillBeAsymmetricDueToReadOnlyMember, data);
+		}
+
+		public static class PolymorphicTrace
+		{
+			private static readonly DiagnosticSource Source = new DiagnosticListener("MsgPack.Serialization.Generators.Polymorphic.Trace");
+
+			public static bool IsEnabled(string key)
+				=> Source.IsEnabled(key);
+
+			public static class Keys
+			{
+				public const string DefaultSchemaForValueType = "DefaultSchemaForValueType";
+				public const string SchemaCreatedForRootType = "SchemaCreatedForRootType";
+				public const string DefaultSchemaForUnqualifiedCollectionMember = "DefaultSchemaForUnqualifiedCollectionMember";
+				public const string SchemaCreatedForCollectionMember = "SchemaCreatedForCollectionMember";
+				public const string DefaultSchemaForUnqualifiedDictionaryMember = "DefaultSchemaForUnqualifiedDictionaryMember";
+				public const string SchemaCreatedForDictionaryMember = "SchemaCreatedForDictionaryMember";
+				public const string DefaultSchemaForUnqualifiedTupleMember = "DefaultSchemaForUnqualifiedTupleMember";
+				public const string SchemaCreatedForTupleMember = "SchemaCreatedForTupleMember";
+				public const string DefaultSchemaForUnqualifiedObjectMember = "DefaultSchemaForUnqualifiedObjectMember";
+				public const string SchemaCreatedForObjectMember = "SchemaCreatedForObjectMember";
+			}
+
+			public static void DefaultSchemaForValueType(object data)
+				=> Source.Write(Keys.DefaultSchemaForValueType, data);
+
+			public static void SchemaCreatedForRootType(object data)
+				=> Source.Write(Keys.SchemaCreatedForRootType, data);
+
+			public static void DefaultSchemaForUnqualifiedCollectionMember(object data)
+				=> Source.Write(Keys.DefaultSchemaForUnqualifiedCollectionMember, data);
+
+			public static void SchemaCreatedForCollectionMember(object data)
+				=> Source.Write(Keys.SchemaCreatedForCollectionMember, data);
+
+			public static void DefaultSchemaForUnqualifiedDictionaryMember(object data)
+				=> Source.Write(Keys.DefaultSchemaForUnqualifiedDictionaryMember, data);
+
+			public static void SchemaCreatedForDictionaryMember(object data)
+				=> Source.Write(Keys.SchemaCreatedForDictionaryMember, data);
+
+			public static void DefaultSchemaForUnqualifiedTupleMember(object data)
+				=> Source.Write(Keys.DefaultSchemaForUnqualifiedTupleMember, data);
+
+			public static void SchemaCreatedForTupleMember(object data)
+				=> Source.Write(Keys.SchemaCreatedForTupleMember, data);
+
+			public static void DefaultSchemaForUnqualifiedObjectMember(object data)
+				=> Source.Write(Keys.DefaultSchemaForUnqualifiedObjectMember, data);
+
+			public static void SchemaCreatedForObjectMember(object data)
+				=> Source.Write(Keys.SchemaCreatedForObjectMember, data);
+		}
+
+	}
+}
+
diff --git a/src/MsgPack.Serialization/Serialization/Dianostic.tt b/src/MsgPack.Serialization/Serialization/Dianostic.tt
new file mode 100644
index 000000000..d63e2cebf
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Dianostic.tt
@@ -0,0 +1,140 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+const string prefix = "MsgPack.Serialization";
+
+var listeners =
+	new []
+	{
+		new
+		{
+			Name = "General",
+			FullName = prefix,
+			Events =
+				new Event[]
+				{
+					"AotError",
+					"HoistUpInnerExceptionFailed",
+				}
+		},
+		new
+		{
+			Name = "GeneratorTrace",
+			FullName = prefix + ".Generators.Trace",
+			Events =
+				new Event[]
+				{
+					"DetectedAsDeserializable",
+					"DeserializationConstructorFound",
+					"SkipStaticMember",
+					"SkipIndexer",
+					"SkipSetOnlyProperty",
+					"SkipMemberDueToAccessibility",
+					"UseCollectionAddForReadOnlyMember",
+					"UseConstructorForMemberAccessDueToAccessibility",
+					"UseConstructorForMemberAccessDueToReadOnly",
+					"UseDelegateForMemberAccess",
+					"UseDirectMemberAccessDueToPublic",
+					"UseDirectMemberAccessDueToInternalsVisibleTo",
+					"UseIgnoreAccessChecksToAttributeForMemberAccess",
+					"UseReflectionMemberAccess",
+					"WillBeAsymmetricDueToReadOnlyMember"
+				}
+		},
+		new
+		{
+			Name = "PolymorphicTrace",
+			FullName = prefix + ".Generators.Polymorphic.Trace",
+			Events =
+				new Event[]
+				{
+					"DefaultSchemaForValueType",
+					"SchemaCreatedForRootType",
+					"DefaultSchemaForUnqualifiedCollectionMember",
+					"SchemaCreatedForCollectionMember",
+					"DefaultSchemaForUnqualifiedDictionaryMember",
+					"SchemaCreatedForDictionaryMember",
+					"DefaultSchemaForUnqualifiedTupleMember",
+					"SchemaCreatedForTupleMember",
+					"DefaultSchemaForUnqualifiedObjectMember",
+					"SchemaCreatedForObjectMember",
+				}
+		},
+	};
+#>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+#nullable enable
+
+using System.Diagnostics;
+
+namespace MsgPack.Serialization
+{
+	internal static class Diagnostic
+	{
+<#
+foreach (var listener in listeners)
+{
+#>
+		public static class <#= listener.Name #>
+		{
+			private static readonly DiagnosticSource Source = new DiagnosticListener("<#= listener.FullName #>");
+
+			public static bool IsEnabled(string key)
+				=> Source.IsEnabled(key);
+
+			public static class Keys
+			{
+<#
+	foreach (var @event in listener.Events)
+	{
+#>
+				public const string <#= @event.Name #> = "<#= @event.Name #>";
+<#
+	}
+#>
+			}
+<#
+	foreach (var @event in listener.Events)
+	{
+#>
+
+			public static void <#= @event.Name #>(<#= @event.DataType ?? "object" #> data)
+				=> Source.Write(Keys.<#= @event.Name #>, data);
+<#
+	}
+#>
+		}
+
+<#
+}
+#>
+	}
+}
+
+<#+
+class Event
+{
+	public string Name { get; }
+
+	public string? DataType { get; set; }
+
+	public Event (string name)
+	{
+		this.Name = name;
+	}
+
+	public static implicit operator Event(string name)
+		=> new Event(name);
+}
+#>
diff --git a/src/MsgPack.Serialization/Serialization/DictionarySerializationOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/DictionarySerializationOptionsBuilder.cs
new file mode 100644
index 000000000..4e64fdf09
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DictionarySerializationOptionsBuilder.cs
@@ -0,0 +1,110 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+#warning TODO: Write description that this option only affect object serialization!
+	/// <summary>
+	///		Builder object for dictionary (map) serialization options.
+	/// </summary>
+	public sealed class DictionarySerializationOptionsBuilder
+	{
+		/// <summary>
+		///		Gets a value indicating whether omit key-value entry itself when the value is <c>null</c>.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if key-value entry itself when the value is <c>null</c>; otherwise, <c>false</c>.
+		///		The default is <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		When the value is <c>false</c>, null value entry is emitted as following (using JSON syntax for easy visualization):
+		///		<code><pre>
+		///		{ "Foo": null }
+		///		</pre></code>
+		///		else, the value is <c>true</c>, null value entry is ommitted as following:
+		///		<code><pre>
+		///		{}
+		///		</pre></code>
+		/// </remarks>
+		public bool OmitsNullEntries { get; private set; }
+
+		/// <summary>
+		///		Gets a key name handler which enables dictionary key name customization.
+		/// </summary>
+		/// <value>
+		///		A key name handler which enables dictionary key name customization.
+		///		The default value is <c>null</c>, which indicates that key name is not transformed.
+		/// </value>
+		/// <see cref="DictionaryKeyTransformers"/>
+		public Func<string, string>? KeyTransformer { get; private set; }
+
+		/// <summary>
+		///		Indicates that emitting key-value entry itself even when the value is <c>null</c>.
+		/// </summary>
+		/// <returns>This <see cref="DictionarySerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="OmitsNullEntries"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public DictionarySerializationOptionsBuilder EmitNullEntries()
+		{
+			this.OmitsNullEntries = false;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates that omitting key-value entry itself when the value is <c>null</c>.
+		/// </summary>
+		/// <returns>This <see cref="DictionarySerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		When the value is <c>false</c>, null value entry is emitted as following (using JSON syntax for easy visualization):
+		///		<code><pre>
+		///		{ "Foo": null }
+		///		</pre></code>
+		///		else, the value is <c>true</c>, null value entry is ommitted as following:
+		///		<code><pre>
+		///		{}
+		///		</pre></code>
+		/// </remarks>
+		public DictionarySerializationOptionsBuilder OmitNullEntries()
+		{
+			this.OmitsNullEntries = true;
+			return this;
+		}
+
+
+		/// <summary>
+		///		Sets <see cref="KeyTransformer"/> property to default (no name transformation).
+		/// </summary>
+		/// <returns>This <see cref="DictionarySerializationOptionsBuilder"/> instance.</returns>
+		public DictionarySerializationOptionsBuilder UseDefaultKeyTransformer()
+		{
+			this.KeyTransformer = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets <see cref="KeyTransformer"/> property with specified transformer delegate.
+		/// </summary>
+		/// <param name="value">
+		///		The delegate which accept original key and then returns serialized key.
+		/// </param>
+		/// <returns>This <see cref="DictionarySerializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="value"/> is <c>null</c>.
+		/// </exception>
+		public DictionarySerializationOptionsBuilder UseCustomKeyTransformer(Func<string, string> value)
+		{
+			this.KeyTransformer = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="DictionarySerializationOptionsBuilder" /> object.
+		/// </summary>
+		public DictionarySerializationOptionsBuilder() { }
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/DynamicEnumSerializer`1.cs b/src/MsgPack.Serialization/Serialization/DynamicEnumSerializer`1.cs
new file mode 100644
index 000000000..69cfe5ae0
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/DynamicEnumSerializer`1.cs
@@ -0,0 +1,51 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using MsgPack.Codecs;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Facade serializer of enum serializers which are determined in runtime by codec feature of <see cref="FormatEncoder"/>.
+	/// </summary>
+	/// <typeparam name="T">The type of the target enum type.</typeparam>
+	internal sealed class DynamicEnumSerializer<T> : NonCollectionObjectSerializer<T>
+	{
+		private readonly ObjectSerializer<T> _byName;
+		private readonly ObjectSerializer<T> _byUnderlyingValue;
+
+		public DynamicEnumSerializer(
+			SerializerProvider ownerProvider,
+			ObjectSerializer<T> byName,
+			ObjectSerializer<T> byUnderlyingValue
+		) : base(ownerProvider)
+		{
+			this._byName = byName;
+			this._byUnderlyingValue = byUnderlyingValue;
+		}
+
+		private ObjectSerializer<T> GetSerializer(CodecFeatures features)
+			=> this.OwnerProvider.SerializerGenerationOptions.EnumOptions.GetSerializationMethod(features) == EnumSerializationMethod.ByName ?
+				this._byName :
+				this._byUnderlyingValue;
+
+		public override void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink)
+			=> this.GetSerializer(context.Encoder.Options.Features).Serialize(ref context, obj, sink);
+
+		[return: MaybeNull]
+		public sealed override T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> this.GetSerializer(context.Decoder.Options.Features).Deserialize(ref context, ref source);
+
+#if FEATURE_TAP
+
+		public sealed override ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+			=> this.GetSerializer(context.Decoder.Options.Features).DeserializeAsync(context, source);
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/EnumSerializationOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/EnumSerializationOptionsBuilder.cs
new file mode 100644
index 000000000..0be754bc1
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/EnumSerializationOptionsBuilder.cs
@@ -0,0 +1,193 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Builder object for enum serialization options.
+	/// </summary>
+	public sealed class EnumSerializationOptionsBuilder
+	{
+		/// <summary>
+		///		Gets an internal cached default instance.
+		/// </summary>
+		/// <value>
+		///		An internal cached default instance.
+		/// </value>
+		internal static EnumSerializationOptionsBuilder Default { get; } = new EnumSerializationOptionsBuilder();
+
+		/// <summary>
+		///		Gets the <see cref="EnumSerializationMethod"/> to determine default enum serialization method.
+		/// </summary>
+		/// <param name="codecFeatures"><see cref="CodecFeatures"/> which holds default enum serialization method of the codec.</param>
+		/// <returns>
+		///		The <see cref="EnumSerializationMethod"/> to determine default enum serialization method.
+		/// </returns>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="EnumSerialization"]'/>
+		/// </remarks>
+		public EnumSerializationMethod? SerializationMethod { get; private set; }
+
+		/// <summary>
+		///		Gets the name handler which enables customization of enum values serialization by their names.
+		/// </summary>
+		/// <value>
+		///		The name handler which enables customization of enum values serialization by their names.
+		///		The default value is <c>null</c>, which indicates that value is not transformed.
+		/// </value>
+		/// <remarks>
+		///		This value will only affect when <see cref="P:SerializationMethod"/> is set to <see cref="EnumSerializationMethod.ByName"/>.
+		///		In addition, deserialization is always done by case insensitive manner.
+		/// </remarks>
+		public Func<string, string>? NameTransformer { get; private set; }
+
+		/// <summary>
+		///		Gets the value whether of member names are ignored in deserialization or not.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if casing of member names are ignored in deserialization; <c>false</c>, otherwise.
+		/// </value>
+		public bool IgnoresCaseOnDeserialization { get; private set; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="EnumSerializationOptionsBuilder"/> object.
+		/// </summary>
+		public EnumSerializationOptionsBuilder() { }
+
+		/// <summary>
+		///		Directly sets <see cref="SerializationMethod"/> property for compatibility layer.
+		/// </summary>
+		/// <param name="value">Value to set.</param>
+		internal void InternalSetSerializationMethod(EnumSerializationMethod? value)
+			=> this.SerializationMethod = value;
+
+		/// <summary>
+		///		Indicates enum values will be serialized with their name by default.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method sets <see cref="SerializationMethod"/> property to <see cref="EnumSerializationMethod.ByName"/>.
+		/// </remarks>
+		public EnumSerializationOptionsBuilder SerializeByName()
+		{
+			this.SerializationMethod = EnumSerializationMethod.ByName;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates enum values will be serialized with their underlying value by default.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method sets <see cref="SerializationMethod"/> property to <see cref="EnumSerializationMethod.ByUnderlyingValue"/>.
+		/// </remarks>
+		public EnumSerializationOptionsBuilder SerializeByUnderlyingValue()
+		{
+			this.SerializationMethod = EnumSerializationMethod.ByUnderlyingValue;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates enum values will be serialized with <see cref="CodecFeatures.PreferredEnumSerializationMethod"/>.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="SerializationMethod"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public EnumSerializationOptionsBuilder SerializeByCodecPreferredMethod()
+		{
+			this.SerializationMethod = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates no name tranformation is used.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="NameTransformer"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public EnumSerializationOptionsBuilder UseDefaultNameTransformer()
+		{
+			this.NameTransformer = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets <see cref="NameTransformer"/> property with specified transformer delegate.
+		/// </summary>
+		/// <param name="value">
+		///		A delegate which accept original member name and then returns serialized name.
+		/// </param>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="value"/> is <c>null</c>.
+		/// </exception>
+		public EnumSerializationOptionsBuilder UseCustomNameTransformer(Func<string, string> value)
+		{
+			this.NameTransformer = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates using name tranformation between PascalCasing (UpperCamelCasing) and lowerCamelCasing.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		public EnumSerializationOptionsBuilder UseLowerCamelCasingNameTransformer()
+		{
+			this.NameTransformer = KeyNameTransformers.ToLowerCamel;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates using name tranformation between PascalCasing (UpperCamelCasing) and UPPER_SNAKE_CASING.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		public EnumSerializationOptionsBuilder UseUpperSnakeCasingNameTransformer()
+		{
+			this.NameTransformer = KeyNameTransformers.ToUpperSnake;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates using name tranformation between PascalCasing (UpperCamelCasing) and lower_snake_casing.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		public EnumSerializationOptionsBuilder UseLowerSnakeCasingNameTransformer()
+		{
+			this.NameTransformer = KeyNameTransformers.ToUpperSnake;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates ingoring casing on deserialization.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		public EnumSerializationOptionsBuilder IgnoreCaseOnDeserialization()
+		{
+			this.IgnoresCaseOnDeserialization = true;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates distinct casing on deserialization.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="IgnoresCaseOnDeserialization"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public EnumSerializationOptionsBuilder DistinctCaseOnDeserialization()
+		{
+			this.IgnoresCaseOnDeserialization = false;
+			return this;
+		}
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/IBindingOptions.cs b/src/MsgPack.Serialization/Serialization/IBindingOptions.cs
new file mode 100644
index 000000000..5dc665f90
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/IBindingOptions.cs
@@ -0,0 +1,46 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines internal interface of binding options.
+	/// </summary>
+	internal interface IBindingOptions
+	{
+		/// <summary>
+		///		Gets a value which indicates whether non-public member access from serializer should be 
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if privileged access for non public types or members is disabled; <c>false</c>, otherwise.
+		/// </value>
+		bool IsPrivilegedAccessDisabled { get; }
+
+		/// <summary>
+		///		Gets the value which indicates whether non-public member access can be assumed to be enabled relying on <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if non public types or members is non-public member access can be assumed to be enabled relying on <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		If this property is <c>true</c>, genenrators emit code with normal access even though the member or type is not public.
+		///		Note that the generated serializer will belong to the assembly which has <see cref="RuntimeCodeGenerationAssemblyName"/> in runtime code generation,
+		///		so the assembly which declares target type must be marked with <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> for the <see cref="RuntimeCodeGenerationAssemblyName"/> without any public key.
+		///		Also, for source code generation, the assembly which declares target type must be marked with <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> for the assembly name of compiled serializer without any public key.
+		///		In this case, the assembly name will be specified via compiler option (or specified with appropriate settings in <c>.csproj</c> or to be its file name).
+		/// </remarks>
+		bool AssumesInternalsVisibleTo { get; }
+
+		/// <summary>
+		///		Get the collection which contains ignoring member names of the target type.
+		/// </summary>
+		/// <param name="targetType">The target type.</param>
+		/// <returns>The collection which contains ignoring member names of the target type. Empty for no members should be excluded.</returns>
+		IEnumerable<string> GetIgnoringMembers(Type targetType);
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/IDateTimeSerializationOptions.cs b/src/MsgPack.Serialization/Serialization/IDateTimeSerializationOptions.cs
new file mode 100644
index 000000000..d47d1ff63
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/IDateTimeSerializationOptions.cs
@@ -0,0 +1,61 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines interface of date time serialization related options.
+	/// </summary>
+	internal interface IDateTimeSerializationOptions
+	{
+		/// <summary>
+		///		Gets the collection which contains types which will be considered as date-time like type.
+		/// </summary>
+		/// <value>
+		///		The collection which contains types which will be considered as date-time like type.
+		/// </value>
+		ISet<Type> KnownDateTimeLikeTypes { get; }
+
+		/// <summary>
+		///		Gets the default value of date time conversion method for specified codec.
+		/// </summary>
+		/// <param name="codecFeatures">The feature of the codec.</param>
+		/// <returns>
+		///		<see cref="DateTimeConversionMethod"/> for specified codec features.
+		///		If an any value is set via builder object, the value will be returned,
+		///		else returns <see cref="CodecFeatures.PreferredDateTimeConversionMethod"/>.
+		/// </returns>
+		DateTimeConversionMethod GetDefaultDateTimeConversionMethod(CodecFeatures codecFeatures);
+
+		/// <summary>
+		///		Gets the precision of fraction portion on ISO 8601 date time string as specified for specified codec.
+		/// </summary>
+		/// <param name="codecFeatures">The feature of the codec.</param>
+		/// <returns>
+		///		The precision of fraction portion on ISO 8601 date time string for specified codec features.
+		///		If an any value is set via builder object, the value will be returned,
+		///		else returns <see cref="CodecFeatures.Iso8601FractionOfSecondsPrecision"/>.
+		///		<c>null</c> means that the serializer implementation's default should be used.
+		/// </returns>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		int? GetIso8601SubsecondsPrecision(CodecFeatures codecFeatures);
+
+		/// <summary>
+		///		Gets the separator char for fraction portion.
+		/// </summary>
+		/// <returns>
+		///		The separator char for fraction portion on ISO 8601 date time string for specified codec features.
+		///		If an any value is set via builder object, the value will be returned,
+		///		else returns <see cref="CodecFeatures.Iso8601DecimalSeparator"/>.
+		///		<c>null</c> means that the serializer implementation's default should be used.
+		/// </returns>
+		char? GetIso8601DecimalMark(CodecFeatures codecFeatures);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/IDefaultConcreteTypeRepository.cs b/src/MsgPack.Serialization/Serialization/IDefaultConcreteTypeRepository.cs
new file mode 100644
index 000000000..641edee0e
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/IDefaultConcreteTypeRepository.cs
@@ -0,0 +1,76 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines internal interface for the repository of known concrete collections type for abstract collection types on deserialization. 
+	/// </summary>
+	internal interface IDefaultConcreteTypeRepository
+	{
+		/// <summary>
+		///		Gets the default type for the collection.
+		/// </summary>
+		/// <param name="abstractCollectionType">Type of the abstract collection.</param>
+		/// <returns>
+		///		Type of default concrete collection.
+		///		If concrete collection type of <paramref name="abstractCollectionType"/>, then returns <c>null</c>.
+		/// </returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="abstractCollectionType"/> is <c>null</c>.
+		/// </exception>
+		/// <remarks>
+		///		By default, following types are registered:
+		///		<list type="table">
+		///			<listheader>
+		///				<term>Abstract Collection Type</term>
+		///				<description>Concrete Default Collection Type</description>
+		///			</listheader>
+		///			<item>
+		///				<term><see cref="IEnumerable{T}"/></term>
+		///				<description><see cref="List{T}"/></description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="ICollection{T}"/></term>
+		///				<description><see cref="List{T}"/></description>
+		///			</item>
+		///			<item>
+		///				<term><c>ISet{T}</c> (.NET 4 or lator)</term>
+		///				<description><see cref="HashSet{T}"/></description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="IList{T}"/></term>
+		///				<description><see cref="List{T}"/></description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="IDictionary{TKey,TValue}"/></term>
+		///				<description><see cref="Dictionary{TKey,TValue}"/></description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="IEnumerable"/></term>
+		///				<description><see cref="List{T}"/> of <see cref="MessagePackObject"/>.</description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="ICollection"/></term>
+		///				<description><see cref="List{T}"/> of <see cref="MessagePackObject"/>.</description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="IList"/></term>
+		///				<description><see cref="List{T}"/> of <see cref="MessagePackObject"/>.</description>
+		///			</item>
+		///			<item>
+		///				<term><see cref="IDictionary"/></term>
+		///				<description><see cref="MessagePackObjectDictionary"/></description>
+		///			</item>
+		///		</list>
+		/// </remarks>
+		Type? Get(Type abstractCollectionType);
+
+		IEnumerable<KeyValuePair<RuntimeTypeHandle, object>> AsEnumerable();
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/IDictionarySerializationOptions.cs b/src/MsgPack.Serialization/Serialization/IDictionarySerializationOptions.cs
new file mode 100644
index 000000000..d972f2dae
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/IDictionarySerializationOptions.cs
@@ -0,0 +1,45 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Provides dictionary (map) serialization options.
+	/// </summary>
+	/// <remarks>
+	///		These options affect both of object serialization with <see cref="SerializationMethod.Map"/> and dictionary types serialization.
+	/// </remarks>
+	internal interface IDictionarySerializationOptions 
+	{
+		/// <summary>
+		///		Gets the value indicating whether omit key-value entry itself when the value is <c>null</c>.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if key-value entry itself when the value is <c>null</c>; otherwise, <c>false</c>.
+		///		The default is <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		When the value is <c>false</c>, null value entry is emitted as following (using JSON syntax for easy visualization):
+		///		<code><pre>
+		///		{ "Foo": null }
+		///		</pre></code>
+		///		else, the value is <c>true</c>, null value entry is ommitted as following:
+		///		<code><pre>
+		///		{}
+		///		</pre></code>
+		/// </remarks>
+		bool OmitsNullEntries { get; }
+
+		/// <summary>
+		///		Gets the key name handler which enables dictionary key name customization.
+		/// </summary>
+		/// <value>
+		///		The key name handler which enables dictionary key name customization.
+		/// </value>
+		/// <see cref="DictionaryKeyTransformers"/>
+		Func<string, string> KeyTransformer { get; }
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/IEnumSerializationOptions.cs b/src/MsgPack.Serialization/Serialization/IEnumSerializationOptions.cs
new file mode 100644
index 000000000..6d6880f5c
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/IEnumSerializationOptions.cs
@@ -0,0 +1,47 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines enum serialization options.
+	/// </summary>
+	internal interface IEnumSerializationOptions
+	{
+		/// <summary>
+		///		Gets the <see cref="EnumSerializationMethod"/> to determine default enum serialization method.
+		/// </summary>
+		/// <param name="codecFeatures"><see cref="CodecFeatures"/> which holds default enum serialization method of the codec.</param>
+		/// <returns>
+		///		The <see cref="EnumSerializationMethod"/> to determine default enum serialization method.
+		/// </returns>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="EnumSerialization"]'/>
+		/// </remarks>
+		EnumSerializationMethod GetSerializationMethod(CodecFeatures codecFeatures);
+
+		/// <summary>
+		///		Gets the name handler which enables customization of enum values serialization by their names.
+		/// </summary>
+		/// <value>
+		///		The name handler which enables customization of enum values serialization by their names.
+		/// </value>
+		/// <remarks>
+		///		This value will only affect when <see cref="P:SerializationMethod"/> is set to <see cref="EnumSerializationMethod.ByName"/>.
+		///		In addition, deserialization is always done by case insensitive manner.
+		/// </remarks>
+		Func<string, string> NameTransformer { get; }
+
+		/// <summary>
+		///		Gets a value whether of member names are ignored in deserialization or not.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if casing of member names are ignored in deserialization; <c>false</c>, otherwise.
+		/// </value>
+		bool IgnoresCaseOnDeserialization { get; }
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/IObjectSerializerProvider.cs b/src/MsgPack.Serialization/Serialization/IObjectSerializerProvider.cs
new file mode 100644
index 000000000..127e82b6a
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/IObjectSerializerProvider.cs
@@ -0,0 +1,24 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.ComponentModel;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines an interface for an object which provides <see cref="ObjectSerializer"/> for the specified parameter.
+	/// </summary>
+	public interface IObjectSerializerProvider
+	{
+		/// <summary>
+		///		Gets 
+		/// </summary>
+		/// <param name="targetType"></param>
+		/// <param name="providerParameter"></param>
+		/// <returns></returns>
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		ObjectSerializer GetSerializer(Type targetType, object? providerParameter);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ISerializationCompatibilityOptions.cs b/src/MsgPack.Serialization/Serialization/ISerializationCompatibilityOptions.cs
new file mode 100644
index 000000000..fb505f1d9
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ISerializationCompatibilityOptions.cs
@@ -0,0 +1,119 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Represents compatibility options of serialization runtime.
+	/// </summary>
+	/// <remarks>
+	///		A term 'compatibility' has 2 meanings:
+	///		<list type="number">
+	///			<item>Backward compatibility for old design.</item>
+	///			<item>User code compatibility for other wellknown libraries.</item>
+	///		</list>
+	/// </remarks>
+	internal interface ISerializationCompatibilityOptions
+	{
+		/// <summary>
+		///		Gets the value indicating whether array serialization method should use 1 bound order instead of default 0 bound order.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the array serialization method should use 1 bound order; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		Using this value, you can switch between MessagePack for CLI and ProtoBuf.NET seamlessly.
+		/// </remarks>
+		bool UsesOneBoundDataMemberOrder { get; }
+
+		/// <summary>
+		///		Gets the value indicating whether collection serialization runtime should ignore adapter interfaces.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the collection serialization runtime should ignore adapter interfaces; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		<para>
+		///			Adapter interfaces are interfaces which are qualified with <see cref="CompatibilityAdapterAttribute"/>.
+		///		</para>
+		///		<para>
+		///			Historically, MessagePack for CLI ignored packability interfaces (<c>IPackable</c>, <c>IUnpackable</c>, 
+		///			<c>IAsyncPackable"</c> and <c>IAsyncUnpackable</c>) for collection which implements <see cref="IEquatable{T}"/> (except <see cref="String"/> and its kinds).
+		///			As of 0.7, the generator respects such interfaces even if the target type is collection.
+		///			Although this behavior is desirable and correct, setting this property <c>true</c> turn out the new behavior for backward compatibility.
+		///		</para>
+		/// </remarks>
+		bool IgnoresAdapterForCollection { get; }
+
+		/// <summary>
+		///		Gets the value indicating whether serialization runtime should serialize a type implementing <see cref="IEnumerable"/> as a normal type if a public <c>Add</c> method is not found
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if serialization runtime should serialize a type implementing <see cref="IEnumerable"/> as a normal type if a public <c>Add</c> method is not found; otherwise, <c>false</c>. The default is <c>true</c>.
+		/// </value>
+		/// <remarks>
+		///		Historically, MessagePack for CLI always tried to serialize any type that implemented <see cref="IEnumerable"/> as a collection, throwing an exception
+		///		if an <c>Add</c> method could not be found. However, for types that implement <see cref="IEnumerable"/> but don't have an <c>Add</c> method the generator will now
+		///		serialize the type as a non-collection type. To restore the old behavior for backwards compatibility, set this option to <c>false</c>.
+		/// </remarks>
+		bool AllowsNonCollectionEnumerableTypes { get; }
+
+		/// <summary>
+		///		Gets the collection of delegates which detects 'Serializable' interface from an interface type and current options.
+		/// </summary>
+		/// <value>
+		///		The collection of delegates which detects 'Serializable' interface from an interface type and current options.
+		/// </value>
+		/// <remarks>
+		///		This property is used for backward compatibility.
+		///		Note that appropriate <see cref="ObjectSerializer" /> for the interface must be registered to success serialization of types which implements the 'Serializable' interface.
+		/// </remarks>
+		IEnumerable<Func<Type, ISerializerGenerationOptions, bool>> SerializableInterfaceDetectors { get; }
+
+		/// <summary>
+		///		Gets the collection of delegates which detects 'Deserializable' interface from an interface type and current options.
+		/// </summary>
+		/// <value>
+		///		The collection of delegates which detects 'Deserializable' interface from an interface type and current options.
+		/// </value>
+		/// <remarks>
+		///		This property is used for backward compatibility.
+		///		Note that appropriate <see cref="ObjectSerializer" /> for the interface must be registered to success deserialization of types which implements the 'Deserializable' interface.
+		///		In addition, the <see cref="ObjectSerializer"/> implements <see cref="ObjectSerializer.DeserializeObjectTo"/> and related methods
+		///		(<see cref="ObjectSerializer.DeserializeObjectToAsync"/>, <see cref="ObjectSerializer{T}.DeserializeTo"/>, and <see cref="ObjectSerializer{T}.DeserializeToAsync"/>).
+		/// </remarks>
+		IEnumerable<Func<Type, ISerializerGenerationOptions, bool>> DeserializableInterfaceDetectors { get; }
+
+		/// <summary>
+		///		Gets the delegate which provides <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <value>
+		///		The delegate which provides <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		///		Note that 1st argument is attributes of the type, and 2nd argument is of the member.
+		///		If there are no attribute which is compatible to <see cref="MessagePackMemberAttribute"/>, the delegate must return <c>null</c>.
+		/// </value>
+		/// <remarks>
+		///		This property is used for compatibility with other well known libraries.
+		/// </remarks>
+		Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?> MessagePackMemberAttributeCompatibilityProvider { get; }
+
+		/// <summary>
+		///		Gets the delegate which provides <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <value>
+		///		The delegate which provides <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		///		Note that 1st argument is attributes of the type, and 2nd argument is of the member.
+		///		If there are no attribute which is compatible to <see cref="MessagePackIgnoreAttribute"/>, the delegate must return <c>null</c>.
+		/// </value>
+		/// <remarks>
+		///		This property is used for compatibility with other well known libraries.
+		///		Currently, the <see cref="MessagePackIgnoreAttributeData"/> struct has no members, so non-null value means the member is ignored.
+		/// </remarks>
+		Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackIgnoreAttributeData?> IgnoringAttributeCompatibilityProvider { get; }
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ISerializerGenerationOptions.cs b/src/MsgPack.Serialization/Serialization/ISerializerGenerationOptions.cs
new file mode 100644
index 000000000..08d490ce1
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ISerializerGenerationOptions.cs
@@ -0,0 +1,111 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines internal interface for generator.
+	/// </summary>
+	internal interface ISerializerGenerationOptions
+	{
+		/// <summary>
+		///		Gets the value indicating whether the serializer runtime allows serialization even if feature complete serializer cannot be generated due to lack of some requirement.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if the serializer runtime allows serialization even if feature complete serializer cannot be generated due to lack of some requirement; otherwise, <c>false</c>. The default is <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		Currently, the lack of constructor (default or parameterized) or lack of settable members are considerd as "cannot generate feature complete serializer".
+		///		Therefore, you can get serialization only serializer if this property is set to <c>true</c>.
+		///		This is useful for logging, telemetry injestion, or so.
+		///		You can investigate serializer capability via <see cref="Serializer.Capabilities"/> property.
+		/// </remarks>
+		bool AllowsAsymmetricSerializer { get; }
+
+		/// <summary>
+		///		Gets the value which indicates whether on-the-fly runtime code generation is disabled.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if runtime code generation (via <c>System.Reflection.Emit)</c>) is disabled; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		If this value set to <c>false</c>, reflection based serializers will be used if they are activated.
+		///		If it was not activated, only pre-registered serializers will be used.
+		///		Typically, this value will be used for debugging purposes.
+		/// </remarks>
+		bool IsRuntimeCodeGenerationDisabled { get; }
+
+		/// <summary>
+		///		Gets the name of the assembly which holds generated serializer types.
+		/// </summary>
+		/// <value>
+		///		The name of the assembly which holds generated serializer types.
+		/// </value>
+		string RuntimeCodeGenerationAssemblyName { get; }
+
+		/// <summary>
+		///		Gets the <see cref="IBindingOptions"/> object which provides binding related options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="IBindingOptions"/> object which provides binding related options.
+		/// </value>
+		IBindingOptions BindingOptions { get; }
+
+		/// <summary>
+		///		Gets the <see cref="ISerializationCompatibilityOptions"/> object which provides backward or well-known library compatibilities.
+		/// </summary>
+		/// <value>
+		///		The <see cref="ISerializationCompatibilityOptions"/> object which provides backward or well-known library compatibilities.
+		/// </value>
+		ISerializationCompatibilityOptions CompatibilityOptions { get; }
+
+		/// <summary>
+		///		Gets the <see cref="IDictionarySerializationOptions"/> object which provides dictionary serialization options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="IDictionarySerializationOptions"/> object which provides dictionary serialization options.
+		/// </value>
+		IDictionarySerializationOptions DictionaryOptions { get; }
+
+		/// <summary>
+		///		Gets the <see cref="IEnumSerializationOptions"/> object which provides enum serialization options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="IEnumSerializationOptions"/> object which provides enum serialization options.
+		/// </value>
+		IEnumSerializationOptions EnumOptions { get; }
+
+		/// <summary>
+		///		Gets the <see cref="IDateTimeSerializationOptions"/> object which provides <see cref="System.DateTime"/> and simular types serialization options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="IDateTimeSerializationOptions"/> object which provides <see cref="System.DateTime"/> and simular types serialization options.
+		/// </value>
+		IDateTimeSerializationOptions DateTimeOptions { get; }
+
+		/// <summary>
+		///		Gets the <see cref="IDefaultConcreteTypeRepository"/> object which provides concrete type mappings for collection interfaces.
+		/// </summary>
+		/// <value>
+		///		The <see cref="IDefaultConcreteTypeRepository"/> object which provides concrete type mappings for collection interfaces.
+		/// </value>
+		IDefaultConcreteTypeRepository DefaultCollectionTypes { get; }
+
+		/// <summary>
+		///		Gets the <see cref="T:SerializationOptions"/> object wich provides serialization operation level options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="T:SerializationOptions"/> object wich provides serialization operation level options.
+		/// </value>
+		SerializationOptions SerializationOptions { get; }
+
+		/// <summary>
+		///		Gets the <see cref="T:DeserializationOptions"/> object wich provides deserialization operation level options.
+		/// </summary>
+		/// <value>
+		///		The <see cref="T:DeserializationOptions"/> object wich provides deserialization operation level options.
+		/// </value>
+		DeserializationOptions DeserializationOptions { get; }
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableBindingOptions.cs b/src/MsgPack.Serialization/Serialization/ImmutableBindingOptions.cs
new file mode 100644
index 000000000..31a60b4c4
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableBindingOptions.cs
@@ -0,0 +1,36 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Internal <see cref="IBindingOptions"/> implementation.
+	/// </summary>
+	internal sealed class ImmutableBindingOptions : IBindingOptions
+	{
+		public IReadOnlyDictionary<Type, IEnumerable<string>> AllIgnoringMembers { get; }
+
+		/// <inheritdoc />
+		public bool IsPrivilegedAccessDisabled { get; }
+
+		/// <inheritdoc />
+		public bool AssumesInternalsVisibleTo { get; }
+
+		/// <inheritdoc />
+		public IEnumerable<string> GetIgnoringMembers(Type targetType)
+			=> this.AllIgnoringMembers.TryGetValue(targetType, out var result) ? result : Enumerable.Empty<string>();
+
+		public ImmutableBindingOptions(BindingOptionsBuilder builder)
+		{
+			this.AllIgnoringMembers = new Dictionary<Type, IEnumerable<string>>(builder.IgnoringMembers);
+			this.AssumesInternalsVisibleTo = builder.AssumesInternalsVisibleTo;
+			this.IsPrivilegedAccessDisabled = builder.IsPrivilegedAccessDisabled;
+		}
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableDateTimeSerializationOptions.cs b/src/MsgPack.Serialization/Serialization/ImmutableDateTimeSerializationOptions.cs
new file mode 100644
index 000000000..ae6b38844
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableDateTimeSerializationOptions.cs
@@ -0,0 +1,110 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Buffers.Text;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using MsgPack.Codecs;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	internal static class Iso8601
+	{
+		private static ReadOnlySpan<string?> FormatStringsWithPeriod =>
+			new[]
+			{
+				"yyyy-MM-ddTHH:mm:ssK",
+				"yyyy-MM-ddTHH:mm:ss.fK",
+				"yyyy-MM-ddTHH:mm:ss.ffK",
+				"yyyy-MM-ddTHH:mm:ss.fffK",
+				"yyyy-MM-ddTHH:mm:ss.ffffK",
+				"yyyy-MM-ddTHH:mm:ss.fffffK",
+				"yyyy-MM-ddTHH:mm:ss.ffffffK",
+				null,
+				"yyyy-MM-ddTHH:mm:ss.ffffff0K",
+				"yyyy-MM-ddTHH:mm:ss.ffffff00K",
+			};
+
+		private static ReadOnlySpan<string> FormatStringsWithComma =>
+			new[]
+			{
+				"yyyy-MM-ddTHH:mm:ssK",
+				"yyyy-MM-ddTHH:mm:ss,fK",
+				"yyyy-MM-ddTHH:mm:ss,ffK",
+				"yyyy-MM-ddTHH:mm:ss,fffK",
+				"yyyy-MM-ddTHH:mm:ss,ffffK",
+				"yyyy-MM-ddTHH:mm:ss,fffffK",
+				"yyyy-MM-ddTHH:mm:ss,ffffffK",
+				"yyyy-MM-ddTHH:mm:ss,ffffffK",
+				"yyyy-MM-ddTHH:mm:ss,ffffff0K",
+				"yyyy-MM-ddTHH:mm:ss,ffffff00K",
+			};
+
+		public const int MaxLength = 35;
+		public static readonly StandardFormat StandardFormat = new StandardFormat('o');
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static string? GetFormatString(char decimalMark, int fractionPrecision)
+		{
+			Debug.Assert(fractionPrecision >= 0 && fractionPrecision <= 9);
+
+			if (decimalMark == '.')
+			{
+				return FormatStringsWithPeriod[fractionPrecision];
+			}
+			else
+			{
+				Debug.Assert(decimalMark == ',');
+				return FormatStringsWithComma[fractionPrecision];
+			}
+		}
+	}
+
+	/// <summary>
+	///		Immutable implementation of <see cref="IDateTimeSerializationOptions"/>.
+	/// </summary>
+	internal sealed class ImmutableDateTimeSerializationOptions : IDateTimeSerializationOptions
+	{
+		/// <inheritdoc />
+		public ISet<Type> KnownDateTimeLikeTypes { get; }
+
+		private readonly DateTimeConversionMethod? _defaultDateTimeConversionMethod;
+
+		/// <inheritdoc />
+		public DateTimeConversionMethod GetDefaultDateTimeConversionMethod(CodecFeatures codecFeatures)
+		{
+			Debug.Assert(codecFeatures != null);
+			return this._defaultDateTimeConversionMethod ?? codecFeatures.PreferredDateTimeConversionMethod;
+		}
+
+		private readonly int? _iso8601FractionOfSecondsPrecision;
+
+		/// <inheritdoc />
+		public int? GetIso8601SubsecondsPrecision(CodecFeatures codecFeatures)
+			=> codecFeatures?.Iso8601FractionOfSecondsPrecision ?? this._iso8601FractionOfSecondsPrecision;
+
+		private readonly char? _iso8601DecimalMark;
+
+		/// <inheritdoc />
+		public char? GetIso8601DecimalMark(CodecFeatures codecFeatures)
+			=> codecFeatures?.Iso8601DecimalSeparator ?? this._iso8601DecimalMark;
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="IDateTimeSerializationOptions"/> object.
+		/// </summary>
+		/// <param name="builder"><see cref="DateTimeSerializationOptionsBuilder"/>.</param>
+		public ImmutableDateTimeSerializationOptions(DateTimeSerializationOptionsBuilder builder)
+		{
+			this.KnownDateTimeLikeTypes = builder.KnownDateTimeLikeTypeSet;
+			this._iso8601DecimalMark = builder.Iso8601DecimalMark;
+			this._iso8601FractionOfSecondsPrecision = builder.Iso8601FractionOfSecondsPrecision;
+			this._defaultDateTimeConversionMethod = builder.DefaultDateTimeConversionMethod;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableDefaultConcreteTypeRepository.cs b/src/MsgPack.Serialization/Serialization/ImmutableDefaultConcreteTypeRepository.cs
new file mode 100644
index 000000000..5b97edc83
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableDefaultConcreteTypeRepository.cs
@@ -0,0 +1,45 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Internal immutable implementation for <see cref="IDefaultConcreteTypeRepository"/>.
+	/// </summary>
+	internal sealed class ImmutableDefaultConcreteTypeRepository : IDefaultConcreteTypeRepository
+	{
+		internal static ImmutableDefaultConcreteTypeRepository Default { get; } = new DefaultConcreteTypeRepositoryBuilder().Build();
+
+		private readonly Dictionary<RuntimeTypeHandle, object> _defaultCollectionTypes;
+
+		internal ImmutableDefaultConcreteTypeRepository(Dictionary<RuntimeTypeHandle, object> defaultCollectionTypes)
+		{
+			this._defaultCollectionTypes = defaultCollectionTypes;
+		}
+
+		public Type? Get(Type abstractCollectionType)
+		{
+			TypeKeyRepositoryLogics.TryGet(this._defaultCollectionTypes, Ensure.NotNull(abstractCollectionType), out var concrete, out var genericDefinition);
+			return concrete as Type ?? genericDefinition as Type;
+		}
+
+		internal Type? GetConcreteType(Type abstractCollectionType)
+		{
+			var typeOrDefinition = this.Get(abstractCollectionType);
+			if (typeOrDefinition == null || !typeOrDefinition.GetIsGenericTypeDefinition() || !abstractCollectionType.GetIsGenericType())
+			{
+				return typeOrDefinition;
+			}
+
+			// Assume type repository has only concrete generic type definition which has same arity for abstract type.
+			return typeOrDefinition.MakeGenericType(abstractCollectionType.GetGenericArguments());
+		}
+
+		public IEnumerable<KeyValuePair<RuntimeTypeHandle, object>> AsEnumerable()
+			=> this._defaultCollectionTypes;
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableDictionarySerializationOptions.cs b/src/MsgPack.Serialization/Serialization/ImmutableDictionarySerializationOptions.cs
new file mode 100644
index 000000000..514012103
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableDictionarySerializationOptions.cs
@@ -0,0 +1,35 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Immutable implementation of <see cref="IDictionarySerializationOptions"/>.
+	/// </summary>
+	internal sealed class ImmutableDictionarySerializationOptions : IDictionarySerializationOptions
+	{
+		/// <summary>
+		///		Gets an instance with default settings.
+		/// </summary>
+		internal static ImmutableDictionarySerializationOptions Default { get; } = new ImmutableDictionarySerializationOptions(new DictionarySerializationOptionsBuilder());
+
+		/// <inheritdoc />
+		public bool OmitsNullEntries { get; }
+
+		/// <inheritdoc />
+		public Func<string, string> KeyTransformer { get; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="ImmutableDictionarySerializationOptions"/> object.
+		/// </summary>
+		/// <param name="builder"><see cref="DictionarySerializationOptionsBuilder"/>.</param>
+		internal ImmutableDictionarySerializationOptions(DictionarySerializationOptionsBuilder builder)
+		{
+			this.OmitsNullEntries = builder.OmitsNullEntries;
+			this.KeyTransformer = builder.KeyTransformer ?? KeyNameTransformers.AsIs;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableEnumSerializationOptions.cs b/src/MsgPack.Serialization/Serialization/ImmutableEnumSerializationOptions.cs
new file mode 100644
index 000000000..4d3e0378d
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableEnumSerializationOptions.cs
@@ -0,0 +1,35 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Immutable implementation of <see cref="IEnumSerializationOptions"/>.
+	/// </summary>
+	internal sealed class ImmutableEnumSerializationOptions : IEnumSerializationOptions
+	{
+		private readonly EnumSerializationMethod? _serializationMethod;
+
+		/// <inheritdoc />
+		public EnumSerializationMethod GetSerializationMethod(CodecFeatures codecFeatures)
+		{
+			Debug.Assert(codecFeatures != null);
+			return this._serializationMethod ?? codecFeatures.PreferredEnumSerializationMethod;
+		}
+
+		/// <inheritdoc />
+		public Func<string, string> NameTransformer { get; }
+
+		internal ImmutableEnumSerializationOptions(EnumSerializationOptionsBuilder builder)
+		{
+			this._serializationMethod = builder.SerializationMethod;
+			this.NameTransformer = builder.NameTransformer ?? KeyNameTransformers.AsIs;
+		}
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableSerializationCompatibilityOptions.cs b/src/MsgPack.Serialization/Serialization/ImmutableSerializationCompatibilityOptions.cs
new file mode 100644
index 000000000..8c68b1087
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableSerializationCompatibilityOptions.cs
@@ -0,0 +1,55 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Immutable implementation of <see cref="ISerializationCompatibilityOptions"/>.
+	/// </summary>
+	internal sealed class ImmutableSerializationCompatibilityOptions : ISerializationCompatibilityOptions
+	{
+		internal static ImmutableSerializationCompatibilityOptions Default { get; } = new ImmutableSerializationCompatibilityOptions(new SerializationCompatibilityOptionsBuilder());
+
+		/// <inheritdoc />
+		public bool UsesOneBoundDataMemberOrder { get; }
+
+		// Always false
+		/// <inheritdoc />
+		public bool IgnoresAdapterForCollection => false;
+
+		/// <inheritdoc />
+		public bool AllowsNonCollectionEnumerableTypes { get; }
+
+		/// <inheritdoc />
+		public IEnumerable<Func<Type, ISerializerGenerationOptions, bool>> SerializableInterfaceDetectors { get; }
+
+		/// <inheritdoc />
+		public IEnumerable<Func<Type, ISerializerGenerationOptions, bool>> DeserializableInterfaceDetectors { get; }
+
+		/// <inheritdoc />
+		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?> MessagePackMemberAttributeCompatibilityProvider { get; }
+
+		/// <inheritdoc />
+		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackIgnoreAttributeData?> IgnoringAttributeCompatibilityProvider { get; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="ImmutableSerializationCompatibilityOptions"/> object.
+		/// </summary>
+		/// <param name="builder"><see cref="SerializationContextBuilder"/>.</param>
+		public ImmutableSerializationCompatibilityOptions(SerializationCompatibilityOptionsBuilder builder)
+		{
+			this.AllowsNonCollectionEnumerableTypes = builder.AllowsNonCollectionEnumerableTypes;
+			this.UsesOneBoundDataMemberOrder = builder.UsesOneBoundDataMemberOrder;
+			this.SerializableInterfaceDetectors = builder.SerializableAnywayInterfaceDetectors;
+			this.DeserializableInterfaceDetectors = builder.DeserializableInterfaceDetectors;
+			this.MessagePackMemberAttributeCompatibilityProvider = builder.MessagePackMemberAttributeCompatibilityProvider ?? DefaultMessagePackAttributeCompatibilityProviders.DefaultMessagePackMemberAttributeCompatibilityProvider;
+			this.IgnoringAttributeCompatibilityProvider = builder.IgnoringAttributeCompatibilityProvider ?? DefaultMessagePackAttributeCompatibilityProviders.DefaultMessagePackIgnoreAttributeCompatibilityProvider;
+		}
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/ImmutableSerializerGenerationOptions.cs b/src/MsgPack.Serialization/Serialization/ImmutableSerializerGenerationOptions.cs
new file mode 100644
index 000000000..a5a3fbfec
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ImmutableSerializerGenerationOptions.cs
@@ -0,0 +1,101 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		An internal immutable implementation of <see cref="ISerializerGenerationOptions"/>.
+	/// </summary>
+	internal sealed class ImmutableSerializerGenerationOptions : ISerializerGenerationOptions
+	{
+		/// <summary>
+		///		Indicates whether runtime code generation with <c>System.Reflection.Emit</c> can be used in current environment.
+		/// </summary>
+		internal static readonly bool CanEmit = DetermineCanEmit();
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static bool DetermineCanEmit()
+		{
+#if FEATURE_RUNTIME_FEATURES
+			return RuntimeFeature.IsDynamicCodeCompiled;
+#else
+#if (NETSTANDARD1_3 || NETSTANDARD2_0) && !WINDOWS_UWP
+			try
+			{
+				return DetermineCanEmitCore();
+			}
+			catch
+			{
+				return false;
+			}
+#elif NETFX_CORE || UNITY
+			return false;
+#else
+			// Desktop etc.
+			return true;
+#endif
+#endif
+		}
+
+#if (NETSTANDARD1_3 || NETSTANDARD2_0) && !WINDOWS_UWP
+
+		[MethodImpl(MethodImplOptions.NoInlining)]
+		private static bool DetermineCanEmitCore()
+		{
+			return SerializationMethodGeneratorManager.Fast != null;
+		}
+
+#endif // (NETSTANDARD1_3 || NETSTANDARD2_0) && !WINDOWS_UWP
+
+		/// <inheritdoc />
+		public bool AllowsAsymmetricSerializer { get; }
+
+		/// <inheritdoc />
+		public bool IsRuntimeCodeGenerationDisabled { get; }
+
+		/// <inheritdoc />
+		public string RuntimeCodeGenerationAssemblyName { get; }
+
+		/// <inheritdoc />
+		public IBindingOptions BindingOptions { get; }
+
+		/// <inheritdoc />
+		public ISerializationCompatibilityOptions CompatibilityOptions { get; }
+
+		/// <inheritdoc />
+		public IDictionarySerializationOptions DictionaryOptions { get; }
+
+		/// <inheritdoc />
+		public IEnumSerializationOptions EnumOptions { get; }
+
+		/// <inheritdoc />
+		public IDateTimeSerializationOptions DateTimeOptions { get; }
+
+		/// <inheritdoc />
+		public IDefaultConcreteTypeRepository DefaultCollectionTypes { get; }
+
+		/// <inheritdoc />
+		public SerializationOptions SerializationOptions { get; }
+
+		/// <inheritdoc />
+		public DeserializationOptions DeserializationOptions { get; }
+
+		internal ImmutableSerializerGenerationOptions(SerializerGenerationOptionsBuilder builder)
+		{
+			this.AllowsAsymmetricSerializer = builder.AllowsAsymmetricSerializer;
+			this.IsRuntimeCodeGenerationDisabled = builder.IsRuntimeCodeGenerationDisabled;
+			this.RuntimeCodeGenerationAssemblyName = builder.RuntimeCodeGenerationAssemblyName;
+			this.BindingOptions = builder.BuildBindngOptions();
+			this.CompatibilityOptions = builder.BuildCompatibilityOptions();
+			this.DictionaryOptions = builder.BuildDictionaryOptions();
+			this.EnumOptions = builder.BuildEnumOptions();
+			this.DateTimeOptions = builder.BuildDateTimeOptions();
+			this.DefaultCollectionTypes = builder.BuildDefaultCollectionTypes();
+			this.SerializationOptions = builder.BuildSerializationOptions();
+			this.DeserializationOptions = builder.BuildDeserializationOptions();
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/LazyDelegatingObjectSerializer`1.cs b/src/MsgPack.Serialization/Serialization/LazyDelegatingObjectSerializer`1.cs
new file mode 100644
index 000000000..3083ec87b
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/LazyDelegatingObjectSerializer`1.cs
@@ -0,0 +1,86 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Lazily initialized serializer which delegates actual work for another serializer implementation.
+	/// </summary>
+	/// <typeparam name="T">
+	///		The type of target type.
+	/// </typeparam>
+	/// <remarks>
+	///		This serializer is intended to support self-composit structure like directories or XML nodes.
+	/// </remarks>
+	internal sealed class LazyDelegatingObjectSerializer<T> : ObjectSerializer<T>
+	{
+		private readonly object _providerParameter;
+		private ObjectSerializer<T>? _delegated;
+
+		public ObjectSerializer? Delegated => this._delegated;
+
+		/// <summary>
+		///		Initializes a new instance of the <see cref="LazyDelegatingObjectSerializer{T}"/> object.
+		/// </summary>
+		/// <param name="ownerContext">
+		///		The serialization context to support lazy retrieval.
+		///	</param>
+		/// <param name="providerParameter">A provider parameter to be passed in future.</param>
+		public LazyDelegatingObjectSerializer(SerializerProvider ownerProvider, object providerParameter, SerializerCapabilities capabilities)
+			: base(ownerProvider, capabilities)
+		{
+			this._providerParameter = providerParameter;
+		}
+
+		private ObjectSerializer<T> GetDelegatedSerializer()
+		{
+			var result = this._delegated;
+			if (result == null)
+			{
+				var untypedResult = this.ObjectSerializerProvider.GetSerializer(typeof(T), this._providerParameter);
+
+				if (untypedResult is LazyDelegatingObjectSerializer<T>)
+				{
+					throw new InvalidOperationException(
+						$"ObjectSerializer for the type '{typeof(T)}' is not constructed yet. It may indicate race condition or may be caused by cyclic reference."
+					);
+				}
+
+				// Duplicated assignment is accepttable.
+				this._delegated = result = (ObjectSerializer<T>)untypedResult;
+			}
+
+			return result;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink)
+			=> this.GetDelegatedSerializer().Serialize(ref context, obj, sink);
+
+		[return: MaybeNull]
+		public sealed override T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> this.GetDelegatedSerializer().Deserialize(ref context, ref source);
+
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj)
+			=> this.GetDelegatedSerializer().DeserializeTo(ref context, ref source, obj);
+
+#if FEATURE_TAP
+
+		public sealed override ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+			=> this.GetDelegatedSerializer().DeserializeAsync(context, source);
+
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj)
+			=> this.GetDelegatedSerializer().DeserializeToAsync(context, source, obj);
+
+#endif // FEATURE_TAP
+
+		public sealed override string? ToString()
+			=> this.GetDelegatedSerializer().ToString();
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/MemberAccessStrategy.cs b/src/MsgPack.Serialization/Serialization/MemberAccessStrategy.cs
new file mode 100644
index 000000000..87bd7048f
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/MemberAccessStrategy.cs
@@ -0,0 +1,55 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Reflection;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines member access strategy for object serialization.
+	/// </summary>
+	internal enum MemberAccessStrategy
+	{
+		/// <summary>
+		///		Skip the member in serialization.
+		/// </summary>
+		Skip = 0,
+
+		/// <summary>
+		///		Use direct access because it is public.
+		/// </summary>
+		Direct,
+
+		/// <summary>
+		///		Use Core CLR's <c>System.Runtime.CompilerServices.IgnoreAccessChecksToAttribute</c> to skip access check verification for non-public member.
+		/// </summary>
+		DirectWithIgnoreAccessChecksToAttribute,
+
+		/// <summary>
+		///		Use delegate which wraps <see cref="MethodInfo"/> to access non-public member assuming that current thread has enough code access security permission.
+		/// </summary>
+		ViaDelegate,
+
+		/// <summary>
+		///		Use reflection serializer instead of any code generation.
+		/// </summary>
+		WithReflection,
+
+		/// <summary>
+		///		Use constructor for deserialization because no setters exist.
+		/// </summary>
+		ViaConstrutor,
+
+		/// <summary>
+		///		There are no setters and constructors, so only asymmetric serializer can be generated if allowed.
+		/// </summary>
+		WillBeAsymmetric,
+
+		/// <summary>
+		///		Use addition to existing collection instead of setting collection itself because the member is read only and the type is mutable collection.
+		/// </summary>
+		CollectionAdd
+	}
+
+}
diff --git a/src/MsgPack.Serialization/Serialization/MessagePackIgnoreAttributeData.cs b/src/MsgPack.Serialization/Serialization/MessagePackIgnoreAttributeData.cs
new file mode 100644
index 000000000..a013cfb7a
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/MessagePackIgnoreAttributeData.cs
@@ -0,0 +1,14 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization
+{
+	// This is a custom struct instead of raw MessagePackMemberAttribute to reduce GC.
+	/// <summary>
+	///		Represents a data of <see cref="MessagePackIgnoreAttribute"/>.
+	/// </summary>
+	public readonly struct MessagePackIgnoreAttributeData
+	{
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/MessagePackMemberAttributeData.cs b/src/MsgPack.Serialization/Serialization/MessagePackMemberAttributeData.cs
new file mode 100644
index 000000000..72c2ce250
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/MessagePackMemberAttributeData.cs
@@ -0,0 +1,73 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	// This is a custom struct instead of raw MessagePackMemberAttribute to reduce GC.
+	/// <summary>
+	///		Represents a data of <see cref="MessagePackMemberAttribute"/>.
+	/// </summary>
+	public readonly struct MessagePackMemberAttributeData
+	{
+		/// <summary>
+		///		Gets ID of the member.
+		/// </summary>
+		/// <value>
+		///		ID of this member. This value will be array index on serialized stream. This value cannot be negative and must be unique in the type.
+		///		This value may be <c>null</c>, in that case, the qualified member's will be ignored.
+		/// </value>
+		public int? Id { get; }
+
+		/// <summary>
+		///		Gets name of this member.
+		/// </summary>
+		/// <value>
+		///		Name which will be used in map key on serialized stream.
+		///		This value may be <c>null</c>, in that case, the qualified member's name will be used.
+		///		This value must be unique in the type.
+		/// </value>
+		public string? Name { get; }
+
+		/// <summary>
+		///		Gets implication of nil value.
+		/// </summary>
+		/// <value>
+		///		Implication of nil value.
+		///		Default value is <see cref="F:NilImplication.MemberDefault"/>.
+		/// </value>
+		public NilImplication NilImplication { get; }
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="MessagePackMemberAttributeData"/> object.
+		/// </summary>
+		/// <param name="id">ID of this member. This value will be array index on serialized stream. This value cannot be negative and must be unique in the type. This value may be <c>null</c>, in that case, the qualified member's will be ignored.</param>
+		/// <param name="name">Name which will be used in map key on serialized stream. This value may be <c>null</c>, in that case, the qualified member's name will be used. This value must be unique in the type.</param>
+		/// <param name="nilImplication">Implication of nil value.</param>
+		/// <exception cref="ArgumentOutOfRangeException">
+		///		<paramref name="id"/> is negative, or the value of <paramref name="nilImplication" /> is not defined as <see cref="NilImplication"/> enumeration.
+		/// </exception>
+		public MessagePackMemberAttributeData(int? id, string? name, NilImplication nilImplication = NilImplication.MemberDefault)
+		{
+			this.Id = id is null ? default(int?) : Ensure.IsNotLessThan(id.GetValueOrDefault(), 0, nameof(id));
+			this.Name = name;
+			switch (nilImplication)
+			{
+				case NilImplication.MemberDefault:
+				case NilImplication.Null:
+				case NilImplication.Prohibit:
+				{
+					break;
+				}
+				default:
+				{
+					throw new ArgumentOutOfRangeException(nameof(nilImplication));
+				}
+			}
+
+			this.NilImplication = nilImplication;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/MessagePackSerializationMethodAttribute.cs b/src/MsgPack.Serialization/Serialization/MessagePackSerializationMethodAttribute.cs
new file mode 100644
index 000000000..891b1f34e
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/MessagePackSerializationMethodAttribute.cs
@@ -0,0 +1,55 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Marks the type should be serialized with specified <see cref="T:SerializationMethod"/> if available on the underlying codec.
+	/// </summary>
+	/// <remarks>
+	///		This attribute supersedes the option in <see cref="SerializerGenerationOptionsBuilder"/>, but will be ignored when the value is not available on underlying codec.
+	///		The availability of the codec can be checked with <see cref="CodecFeatures.AvailableSerializationMethods"/>.
+	/// </remarks>
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
+	public sealed class MessagePackSerializationMethodAttribute : Attribute
+	{
+		/// <summary>
+		///		Gets a value which indicates <see cref="T:SerializationMethod"/> for the qualified type, if available on the underlying codec.
+		/// </summary>
+		/// <value>
+		///		A value which indicates <see cref="T:SerializationMethod"/> for the qualified type, if available on the underlying codec.
+		/// </value>
+		public SerializationMethod SerializationMethod { get; }
+
+		/// <summary>
+		///		Initialize a new instance of <see cref="MessagePackSerializationMethodAttribute"/> type.
+		/// </summary>
+		/// <param name="serializationMethod">
+		///		A value which indicates <see cref="T:SerializationMethod"/> for the qualified type, if available on the underlying codec.
+		/// </param>
+		/// <exception cref="ArgumentOutOfRangeException">
+		///		<paramref name="serializationMethod"/> is not defined as <see cref="SerializationMethod"/> enumeration.
+		/// </exception>
+		public MessagePackSerializationMethodAttribute(SerializationMethod serializationMethod)
+		{
+			switch (serializationMethod)
+			{
+				case SerializationMethod.Array:
+				case SerializationMethod.Map:
+				{
+					break;
+				}
+				default:
+				{
+					throw new ArgumentOutOfRangeException(nameof(serializationMethod));
+				}
+			}
+
+			this.SerializationMethod = serializationMethod;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/NaiveConcurrentFifoCache`2.cs b/src/MsgPack.Serialization/Serialization/NaiveConcurrentFifoCache`2.cs
new file mode 100644
index 000000000..e8e8ef693
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/NaiveConcurrentFifoCache`2.cs
@@ -0,0 +1,78 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Naive FIFO cache.
+	/// </summary>
+	/// <typeparam name="TKey">Type of key.</typeparam>
+	/// <typeparam name="TValue">Type of value.</typeparam>
+	internal sealed class NaiveConcurrentFifoCache<TKey, TValue> : IDisposable
+		where TKey : notnull
+	{
+		private readonly ReaderWriterLockSlim _lock;
+		private readonly int _capacity;
+		private readonly Queue<TKey> _queue;
+		private readonly Dictionary<TKey, TValue> _cache;
+
+		public NaiveConcurrentFifoCache(int capacity)
+		{
+			Debug.Assert(capacity > 0);
+			this._capacity = capacity;
+			this._queue = new Queue<TKey>(capacity);
+			this._cache = new Dictionary<TKey, TValue>(capacity);
+			this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
+		}
+
+		public void Dispose()
+		{
+			this._lock.Dispose();
+		}
+
+		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
+		{
+			this._lock.EnterReadLock();
+			try
+			{
+				return this._cache.TryGetValue(key, out value);
+			}
+			finally
+			{
+				this._lock.ExitReadLock();
+			}
+		}
+
+		public void Put(TKey key, TValue value, Func<TValue, TValue, TValue> merge)
+		{
+			this._lock.EnterWriteLock();
+			try
+			{
+				if (this._cache.Count == this._capacity)
+				{
+					this._cache.Remove(this._queue.Dequeue());
+				}
+
+				if (this._cache.TryAdd(key, value))
+				{
+					this._queue.Enqueue(key);
+				}
+				else
+				{
+					this._cache[key] = merge(this._cache[key], value);
+				}
+			}
+			finally
+			{
+				this._lock.ExitWriteLock();
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/NameTransformation.cs b/src/MsgPack.Serialization/Serialization/NameTransformation.cs
new file mode 100644
index 000000000..19611d1cd
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/NameTransformation.cs
@@ -0,0 +1,101 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Text;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Implements name tranformation logic.
+	/// </summary>
+	internal static class NameTransformation
+	{
+		/// <summary>
+		///		Converts UpperCamel (Pascal) or lowerCamel cased name to lowerCamel casing.
+		/// </summary>
+		/// <param name="mayBeUpperCamel">Name which is UpperCamel (Pascal) or lowerCamel cased.</param>
+		/// <returns>Name with lowerCamel casing.</returns>
+		public static string ToLowerCamelCase(string mayBeUpperCamel)
+		{
+			if (String.IsNullOrEmpty(mayBeUpperCamel))
+			{
+				return mayBeUpperCamel;
+			}
+
+			if (!Char.IsUpper(mayBeUpperCamel[0]))
+			{
+				return mayBeUpperCamel;
+			}
+
+			var buffer = new StringBuilder(mayBeUpperCamel.Length);
+			buffer.Append(Char.ToLowerInvariant(mayBeUpperCamel[0]));
+			if (mayBeUpperCamel.Length > 1)
+			{
+				buffer.Append(mayBeUpperCamel, 1, mayBeUpperCamel.Length - 1);
+			}
+
+			return buffer.ToString();
+		}
+
+		/// <summary>
+		///		Converts UpperCamel (Pascal) or lowerCamel cased name to UPPER_SNAKE or lower_snake casing.
+		/// </summary>
+		/// <param name="mayBeUpperCamel">Name which is UpperCamel (Pascal) or lowerCamel cased.</param>
+		/// <param name="toBeUpperCase"><c>true</c>, if result should be upper casing; <c>false</c>, should be lower casing.</param>
+		/// <returns>Name with UPPER_SNAKE or lower_snake casing.</returns>
+		public static string ToSnakeCase(string mayBeUpperCamel, bool toBeUpperCase)
+		{
+			if (String.IsNullOrEmpty(mayBeUpperCamel))
+			{
+				return mayBeUpperCamel;
+			}
+
+			var buffer = new StringBuilder(mayBeUpperCamel.Length * 2);
+			char previous = '\0';
+			int index = 0;
+	
+			// Process continuous upper cases in head.
+			for (; index < mayBeUpperCamel.Length; index++)
+			{
+				var c = mayBeUpperCamel[index];
+				if (Char.IsUpper(c))
+				{
+					buffer.Append(toBeUpperCase ? c : Char.ToLowerInvariant(c));
+					previous = c;
+				}
+				else
+				{
+					buffer.Append(toBeUpperCase ? Char.ToUpperInvariant(c) : c);
+					previous = c;
+					index++;
+					break;
+				}
+			}
+
+			// Process remaining
+			for (; index < mayBeUpperCamel.Length; index++)
+			{
+				var c = mayBeUpperCamel[index];
+				if (Char.IsUpper(c))
+				{
+					if (previous != '_')
+					{
+						buffer.Append('_');
+					}
+
+					buffer.Append(toBeUpperCase ? c : Char.ToLowerInvariant(c));
+					previous = c;
+				}
+				else
+				{
+					buffer.Append(toBeUpperCase ? Char.ToUpperInvariant(c) : c);
+					previous = c;
+				}
+			}
+
+			return buffer.ToString();
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/NonCollectionObjectSerializer`1.cs b/src/MsgPack.Serialization/Serialization/NonCollectionObjectSerializer`1.cs
new file mode 100644
index 000000000..1caf007a9
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/NonCollectionObjectSerializer`1.cs
@@ -0,0 +1,39 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines basic features for non collection objects serializers.
+	/// </summary>
+	/// <typeparam name="T">The type of the target object.</typeparam>
+	/// <remarks>
+	///		This type reduces IL size by implementing <see cref="DeserializeTo"/> and its async counter part.
+	/// </remarks>
+	internal abstract class NonCollectionObjectSerializer<T> : ObjectSerializer<T>
+	{
+		protected NonCollectionObjectSerializer(SerializerProvider ownerProvider)
+			: base(ownerProvider, SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) { }
+
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(typeof(T));
+			return default;
+		}
+
+#if FEATURE_TAP
+
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj)
+		{
+			Throw.DeserializeToOnlyAvailableForMutableCollection(typeof(T));
+			return default;
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/NullableObjectSerializer`1.cs b/src/MsgPack.Serialization/Serialization/NullableObjectSerializer`1.cs
new file mode 100644
index 000000000..2438d06c9
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/NullableObjectSerializer`1.cs
@@ -0,0 +1,89 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Implements nullable value type handling.
+	/// </summary>
+	/// <typeparam name="T">The type of the target nullable value type.</typeparam>
+	internal sealed class NullableObjectSerializer<T> : NonCollectionObjectSerializer<T?>
+		where T : struct
+	{
+		private readonly ObjectSerializer<T> _underlying;
+
+		/// <summary>
+		///		Initialized a new instance of the <see cref="NullableObjectSerializer{T}"/> object.
+		/// </summary>
+		/// <param name="ownerProvider">The provider which will own this object.</param>
+		/// <param name="underlying">The serializer which will handle non-null case.</param>
+		public NullableObjectSerializer(
+			SerializerProvider ownerProvider,
+			ObjectSerializer<T> underlying
+		) : base(ownerProvider)
+		{
+			this._underlying = underlying;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, [AllowNull] T? obj, IBufferWriter<byte> sink)
+		{
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			this._underlying.Serialize(ref context, obj.GetValueOrDefault(), sink);
+		}
+
+		[return: MaybeNull]
+		public sealed override T? Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+		{
+			if (context.Decoder.TryDecodeNull(ref source))
+			{
+				return null;
+			}
+
+			return this._underlying.Deserialize(ref context, ref source);
+		}
+
+#if FEATURE_TAP
+
+		public sealed override async ValueTask<T?> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+		{
+			bool wasNull;
+			while(!TryDecodeNull(context, source, out wasNull, out var requestHint))
+			{
+				await source.FetchAsync(requestHint, context.CancellationToken);
+			}
+
+			if (wasNull)
+			{
+				return null;
+			}
+
+			return await this._underlying.DeserializeAsync(context, source);
+		}
+
+		private static bool TryDecodeNull(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out bool result, out int requestHint)
+		{
+			var reader = new SequenceReader<byte>(source.Sequence);
+			result = context.Decoder.TryDecodeNull(ref reader, out requestHint);
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+			return true;
+		}
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ObjectSerializationContext.cs b/src/MsgPack.Serialization/Serialization/ObjectSerializationContext.cs
new file mode 100644
index 000000000..ae350eb30
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ObjectSerializationContext.cs
@@ -0,0 +1,265 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Serialization;
+
+namespace MsgPack.Serialization
+{
+	[Obsolete("Use IObjectSerializerProvider")]
+	public sealed class ObjectSerializationContext
+	{
+		public SerializationOptions Options { get; }
+
+		public ObjectSerializer<T> GetSerializer<T>(object? providerParameter)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
+		{
+			throw new NotImplementedException();
+		}
+	}
+
+	internal static class SerializationMetadataFactory
+	{
+		// Facade for metadata retrieval.
+
+#warning TODO: Move factory logic from SerializationTarget
+
+		public static NameMapper GetEnumMetadata(Type enumType, IEnumSerializationOptions options)
+		{
+			Debug.Assert(enumType.IsEnum);
+			return NameMapper.FromEnum(enumType, options.NameTransformer, options.IgnoresCaseOnDeserialization);
+		}
+
+		public static SerializationTarget GetObjectMetadata(Type targetType, ISerializerGenerationOptions options)
+			=> SerializationTarget.Prepare(options, targetType);
+
+		public static SerializationTarget GetTupleMetadata(Type tupleType)
+			=> SerializationTarget.CreateForTuple(tupleType);
+
+		public static SerializationTarget GetCollectionMetadata(Type collectionInstanceType, CollectionTraits traits, ISerializerGenerationOptions options)
+		{
+			bool canDeserialize;
+			var collectionConstructor = GetCollectionConstructor(collectionInstanceType);
+			if (collectionConstructor == null)
+			{
+				if (!options.AllowsAsymmetricSerializer)
+				{
+					Throw.TargetDoesNotHavePublicDefaultConstructorNorInitialCapacity(collectionInstanceType);
+				}
+
+				// Serialize only.
+				canDeserialize = false;
+			}
+			else
+			{
+				canDeserialize = true;
+			}
+			
+			return SerializationTarget.CreateForCollection(collectionInstanceType, traits, collectionConstructor, canDeserialize);
+		}
+
+		private static ConstructorInfo? GetCollectionConstructor(Type collectionInstanceType)
+		{
+			static bool IsIEqualityComparer(Type type)
+				=> type.GetIsGenericType() && type.GetGenericTypeDefinition() == typeof(IEqualityComparer<>);
+
+			const int noParameters = 0;
+			const int withCapacity = 10;
+			const int withComparer = 11;
+			const int withComparerAndCapacity = 20;
+			const int withCapacityAndComparer = 21;
+
+			ConstructorInfo? constructor = null;
+			var currentScore = -1;
+
+			foreach (var candidate in collectionInstanceType.GetConstructors())
+			{
+				var parameters = candidate.GetParameters();
+				switch (parameters.Length)
+				{
+					case 0:
+					{
+						if (currentScore < noParameters)
+						{
+							constructor = candidate;
+							currentScore = noParameters;
+						}
+
+						break;
+					}
+					case 1:
+					{
+						if (currentScore < withCapacity && parameters[0].ParameterType == typeof(int))
+						{
+							constructor = candidate;
+							currentScore = noParameters;
+						}
+						else if (currentScore < withComparer && IsIEqualityComparer(parameters[0].ParameterType))
+						{
+							constructor = candidate;
+							currentScore = noParameters;
+						}
+						break;
+					}
+					case 2:
+					{
+						if (currentScore < withCapacityAndComparer && parameters[0].ParameterType == typeof(int) && IsIEqualityComparer(parameters[1].ParameterType))
+						{
+							constructor = candidate;
+							currentScore = withCapacityAndComparer;
+						}
+						else if (currentScore < withComparerAndCapacity && parameters[1].ParameterType == typeof(int) && IsIEqualityComparer(parameters[0].ParameterType))
+						{
+							constructor = candidate;
+							currentScore = withComparerAndCapacity;
+						}
+
+						break;
+					}
+				}
+			}
+
+			return constructor;
+		}
+	}
+
+	/// <summary>
+	///		Implementing name mapping logic.
+	/// </summary>
+	internal sealed class NameMapper
+	{
+		private readonly Dictionary<string, string> _originalToSerializedMapping;
+		private readonly Dictionary<string, string> _serializedToOriginalMapping;
+
+		private NameMapper(bool isCaseInsensitive)
+		{
+			var comparer = isCaseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+			this._originalToSerializedMapping = new Dictionary<string, string>(comparer);
+			this._serializedToOriginalMapping = new Dictionary<string, string>(comparer);
+		}
+
+		public string SerializeName(string originalName)
+		{
+			if (!this._originalToSerializedMapping.TryGetValue(originalName, out var result))
+			{
+				Throw.UnknownOriginalName(originalName);
+			}
+
+			return result!;
+		}
+
+		public string DeserializeName(string serializedName)
+		{
+			if (!this._serializedToOriginalMapping.TryGetValue(serializedName, out var result))
+			{
+				Throw.UnknownSerializedName(serializedName);
+			}
+
+			return result!;
+		}
+
+		public static NameMapper FromEnum(Type enumType, Func<string, string> nameTransformer, bool isCaseInsensitive = false)
+		{
+			Debug.Assert(enumType != null);
+			Debug.Assert(enumType.IsEnum);
+
+			return
+				Initialize(
+					enumType.GetFields(BindingFlags.Public | BindingFlags.Static)
+					.Select(f =>
+						{
+							var enumMemberAttribute = f.GetCustomAttribute<EnumMemberAttribute>();
+							if (enumMemberAttribute == null
+								|| !enumMemberAttribute.IsValueSetExplicitly
+								|| String.IsNullOrEmpty(enumMemberAttribute.Value))
+							{
+								return (MemberName: f.Name, ExplicitName: default(string?));
+							}
+
+							return (MemberName: f.Name, ExplicitName: enumMemberAttribute.Value);
+						}
+					),
+					nameTransformer,
+					isCaseInsensitive
+				);
+		}
+
+		public static NameMapper FromObjectMembers(IEnumerable<SerializingMember> members, Func<string, string> nameTransformer, bool isCaseInsensitive = false)
+			=> Initialize(
+				members.Select(m => (MemberName: m.Member.Name, ExplicitName: m.MemberName != m.Member.Name ? m.MemberName : null)),
+				nameTransformer,
+				isCaseInsensitive
+			);
+
+
+		private static NameMapper Initialize(IEnumerable<(string MemberName, string? ExplicitName)> names, Func<string, string> nameTransformer, bool isCaseSensitive)
+		{
+			var mapper = new NameMapper(isCaseSensitive);
+
+			foreach (var name in names)
+			{
+				mapper.Register(name.MemberName, name.ExplicitName ?? nameTransformer(name.MemberName));
+			}
+
+			return mapper;
+		}
+
+		private void Register(string originalName, string serializedName)
+		{
+			if (!this._originalToSerializedMapping.TryAdd(originalName, serializedName))
+			{
+				Throw.DuplicatedOriginalName(originalName);
+			}
+
+			if (!this._serializedToOriginalMapping.TryAdd(serializedName, originalName))
+			{
+				// rollback
+				this._originalToSerializedMapping.Remove(originalName);
+				Throw.DuplicatedSerializedName(serializedName);
+			}
+		}
+	}
+	// TODO: SerializationContext -> SerializerProvider
+	// Sergen
+	public abstract class SerializerProviderBuilder
+	{
+		internal SerializerGenerationOptionsBuilder? OptionsBuilder { get; private set; }
+
+		protected SerializerProvider BuildCore() => new SerializerProvider(this.GetInitializedBuilder());
+
+		protected virtual void ConfigureDefault(SerializerGenerationOptionsBuilder builder)
+		{
+			// nop
+		}
+
+		private SerializerGenerationOptionsBuilder GetInitializedBuilder()
+		{
+			var result = this.OptionsBuilder;
+			if (result == null)
+			{
+				result = this.OptionsBuilder = new SerializerGenerationOptionsBuilder();
+				this.ConfigureDefault(result);
+			}
+
+			return result;
+		}
+
+		public void Configure(Action<SerializerGenerationOptionsBuilder> configure)
+			=> Ensure.NotNull(configure).Invoke(this.GetInitializedBuilder());
+	}
+
+	internal sealed class GenericSerializerProviderBuilder : SerializerProviderBuilder
+	{
+		public SerializerProvider Build() => this.BuildCore();
+	}
+
+}
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs b/src/MsgPack.Serialization/Serialization/ObjectSerializer.cs
similarity index 73%
rename from src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs
rename to src/MsgPack.Serialization/Serialization/ObjectSerializer.cs
index bc65229c1..be0a845ab 100644
--- a/src/MsgPack.Abstraction/Serialization/ObjectSerializer.cs
+++ b/src/MsgPack.Serialization/Serialization/ObjectSerializer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
@@ -10,17 +10,25 @@
 
 namespace MsgPack.Serialization
 {
+	/// <summary>
+	///		Defines basic interface for serializers which handle individual object rather than entire object tree.
+	/// </summary>
+	/// <remarks>
+	///		This object is intended to be used by serializer implementation.
+	///		Applications should use <see cref="Serializer"/> instead.
+	/// </remarks>
 	public abstract class ObjectSerializer
 	{
-		protected ObjectSerializationContext OwnerContext { get; }
+		protected SerializerProvider OwnerProvider { get; }
+		protected IObjectSerializerProvider ObjectSerializerProvider => this.OwnerProvider;
 		public SerializerCapabilities Capabilities { get; }
 		public bool CanSerialize => (this.Capabilities & SerializerCapabilities.Serialize) != 0;
 		public bool CanDeserialize => (this.Capabilities & SerializerCapabilities.Deserialize) != 0;
 		public bool CanDeserializeTo => (this.Capabilities & SerializerCapabilities.DeserializeTo) != 0;
 
-		protected ObjectSerializer(ObjectSerializationContext ownerContext, SerializerCapabilities capabilities)
+		protected ObjectSerializer(SerializerProvider ownerProvider, SerializerCapabilities capabilities)
 		{
-			this.OwnerContext = Ensure.NotNull(ownerContext);
+			this.OwnerProvider = Ensure.NotNull(ownerProvider);
 			this.Capabilities = capabilities;
 		}
 
diff --git a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs b/src/MsgPack.Serialization/Serialization/ObjectSerializer`1.cs
similarity index 85%
rename from src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
rename to src/MsgPack.Serialization/Serialization/ObjectSerializer`1.cs
index 67f688870..6fefbd678 100644
--- a/src/MsgPack.Abstraction/Serialization/ObjectSerializer`1.cs
+++ b/src/MsgPack.Serialization/Serialization/ObjectSerializer`1.cs
@@ -12,12 +12,20 @@
 
 namespace MsgPack.Serialization
 {
+	/// <summary>
+	///		Defines basic interface for serializers which handle individual object rather than entire object tree.
+	/// </summary>
+	/// <typeparam name="T">The type of the target object.</typeparam>
+	/// <remarks>
+	///		This object is intended to be used by serializer implementation.
+	///		Applications should use <see cref="Serializer"/> instead.
+	/// </remarks>
 	public abstract class ObjectSerializer<T> : ObjectSerializer
 	{
 		private static readonly bool CanBeNull = !typeof(T).IsValueType || Nullable.GetUnderlyingType(typeof(T)) != null;
 
-		protected ObjectSerializer(ObjectSerializationContext ownerContext, SerializerCapabilities capabilities)
-			: base(ownerContext, capabilities) { }
+		protected ObjectSerializer(SerializerProvider ownerProvider, SerializerCapabilities capabilities)
+			: base(ownerProvider, capabilities) { }
 
 		public abstract void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink);
 
diff --git a/src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude b/src/MsgPack.Serialization/Serialization/OperationContext.ttinclude
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/OperationContext.ttinclude
rename to src/MsgPack.Serialization/Serialization/OperationContext.ttinclude
diff --git a/src/MsgPack.Serialization/Serialization/Polymorphic/KnownTypePolymorphicObjectSerializer`1.cs b/src/MsgPack.Serialization/Serialization/Polymorphic/KnownTypePolymorphicObjectSerializer`1.cs
new file mode 100644
index 000000000..a6667f006
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Polymorphic/KnownTypePolymorphicObjectSerializer`1.cs
@@ -0,0 +1,138 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+#endif // FEATURE_TAP
+
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization.Polymorphic
+{
+	/// <summary>
+	///		Implements polymorphic serializer which uses closed known types and interoperable ext-type feature.
+	/// </summary>
+	/// <typeparam name="T">The base type of the polymorhic member.</typeparam>
+	internal sealed class KnownTypePolymorphicObjectSerializer<T> : ObjectSerializer<T>
+	{
+		private readonly PolymorphismSchema _schema;
+		private readonly IDictionary<string, RuntimeTypeHandle> _typeHandleMap;
+		private readonly IDictionary<RuntimeTypeHandle, string> _typeCodeMap;
+
+		public KnownTypePolymorphicObjectSerializer(SerializerProvider ownerProvider, PolymorphismSchema schema)
+			: base(ownerProvider, SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize | SerializerCapabilities.DeserializeTo)
+		{
+			if (typeof(T).GetIsValueType())
+			{
+				Throw.ValueTypeCannotBePolymorphic(typeof(T));
+			}
+
+			this._schema = schema.FilterSelf();
+			this._typeHandleMap = BuildTypeCodeTypeHandleMap(schema.CodeTypeMapping);
+			this._typeCodeMap = BuildTypeHandleTypeCodeMap(schema.CodeTypeMapping);
+		}
+
+		private static IDictionary<string, RuntimeTypeHandle> BuildTypeCodeTypeHandleMap(IDictionary<string, Type> typeMap)
+		{
+			return typeMap.ToDictionary(kv => kv.Key, kv => kv.Value.TypeHandle);
+		}
+
+		private static IDictionary<RuntimeTypeHandle, string> BuildTypeHandleTypeCodeMap(IDictionary<string, Type> typeMap)
+		{
+			var result = new Dictionary<RuntimeTypeHandle, string>(typeMap.Count);
+			foreach (var typeHandleTypeCodeMapping in typeMap.GroupBy(kv => kv.Value))
+			{
+				if (typeHandleTypeCodeMapping.Count() > 1)
+				{
+					Throw.TypeIsMappedToMultipleExtensionTypes(
+						typeHandleTypeCodeMapping.Key,
+						typeHandleTypeCodeMapping.Select(kv => kv.Key).ToArray()
+					);
+				}
+
+				result.Add(typeHandleTypeCodeMapping.Key.TypeHandle, typeHandleTypeCodeMapping.First().Key);
+			}
+
+			return result;
+		}
+
+		private ObjectSerializer GetActualTypeSerializer(Type actualType)
+		{
+			var result = this.ObjectSerializerProvider.GetPolymorphicSerializer(actualType, this._schema);
+			if (result == null)
+			{
+				Throw.CannotGetActualTypeSerializer(actualType);
+			}
+
+			return result!;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink)
+		{
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			TypeInfoEncoder.EncodeStart(ref context, sink, this.GetTypeCode(obj));
+			// T is ref type here, so boxing will not be occurred.
+			this.GetActualTypeSerializer(obj.GetType()).SerializeObject(ref context, obj, sink);
+			TypeInfoEncoder.EncodeEnd(ref context, sink);
+		}
+
+		private string GetTypeCode(T obj)
+		{
+			if (!this._typeCodeMap.TryGetValue(obj!.GetType().TypeHandle, out var typeCode))
+			{
+				Throw.TypeIsNotDefinedAsKnownType(obj.GetType());
+				// Never reaches
+			}
+
+			return typeCode!;
+		}
+
+
+		[return: MaybeNull]
+		public sealed override T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> TypeInfoEncoder.Decode(
+					ref context,
+					ref source,
+					(c, p) => this.GetTypeFromCode(c, p),
+					(Type t, ref DeserializationOperationContext x, ref SequenceReader<byte> s) => (T)this.GetActualTypeSerializer(t).DeserializeObject(ref x, ref s)!
+				);
+
+		private Type GetTypeFromCode(string typeCode, long position)
+		{
+			RuntimeTypeHandle typeHandle;
+			if (!this._typeHandleMap.TryGetValue(typeCode, out typeHandle))
+			{
+				Throw.UnknownTypeCode(StringEscape.ForDisplay(typeCode), position);
+			}
+
+			return Type.GetTypeFromHandle(typeHandle);
+		}
+
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj)
+			=> this.GetActualTypeSerializer(Ensure.NotNull(obj).GetType()).DeserializeObjectTo(ref context, ref source, obj);
+
+#if FEATURE_TAP
+		public sealed override ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+			=> TypeInfoEncoder.DecodeAsync(
+					context,
+					source,
+					(c, p) => this.GetTypeFromCode(c, p),
+					async (t, x, s) => ((T)await this.GetActualTypeSerializer(t).DeserializeObjectAsync(x, s).ConfigureAwait(false))!
+				);
+
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj)
+			=> this.GetActualTypeSerializer(Ensure.NotNull(obj).GetType()).DeserializeObjectToAsync(context, source, obj);
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Polymorphic/PolymorphicSerializerProvider.cs b/src/MsgPack.Serialization/Serialization/Polymorphic/PolymorphicSerializerProvider.cs
new file mode 100644
index 000000000..958d04b69
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Polymorphic/PolymorphicSerializerProvider.cs
@@ -0,0 +1,47 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization.Polymorphic
+{
+	internal sealed class PolymorphicSerializerProvider : IObjectSerializerProvider
+	{
+		private readonly ObjectSerializer _defaultSerializer;
+		private readonly PolymorphismSchema _defaultSchema;
+
+		public PolymorphicSerializerProvider(Type targetType, ObjectSerializer defaultSerializer)
+		{
+			this._defaultSerializer = defaultSerializer;
+			this._defaultSchema = PolymorphismSchema.Create(targetType, null);
+		}
+
+		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
+		{
+			var schema = (providerParameter ?? this._defaultSchema) as PolymorphismSchema;
+
+			if (schema == null || schema.UseDefault || schema.TargetType != targetType)
+			{
+				// No schema is applied or this provider is used for container but the schema is only applied for keys/items.
+				if (this._defaultSerializer == null)
+				{
+					Throw.NotSupportedBecauseCannotInstanciateAbstractType(targetType);
+					return default!; // Never reaches
+				}
+
+				// Fallback.
+				return this._defaultSerializer;
+			}
+
+			if (schema.UseTypeEmbedding)
+			{
+				return new TypeEmbedingPolymorphicMessagePackSerializer<T>(context, schema);
+			}
+			else
+			{
+				return new KnownTypePolymorphicMessagePackSerializer<T>(context, schema);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Polymorphic/TypeEmbedingPolymorphicObjectSerializer`1.cs b/src/MsgPack.Serialization/Serialization/Polymorphic/TypeEmbedingPolymorphicObjectSerializer`1.cs
new file mode 100644
index 000000000..1b738d639
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/Polymorphic/TypeEmbedingPolymorphicObjectSerializer`1.cs
@@ -0,0 +1,87 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+#if FEATURE_TAP
+using System.Threading.Tasks;
+using MsgPack.Internal;
+#endif // FEATURE_TAP
+
+
+namespace MsgPack.Serialization.Polymorphic
+{
+	/// <summary>
+	///		Implements polymorphic serializer which uses open types and non-interoperable ext-type tag and .NET type information.
+	/// </summary>
+	/// <typeparam name="T">The base type of the polymorhic member.</typeparam>
+	internal sealed class TypeEmbedingPolymorphicObjectSerializer<T> : ObjectSerializer<T>
+	{
+		private readonly PolymorphismSchema _schema;
+
+		public TypeEmbedingPolymorphicObjectSerializer(SerializerProvider ownerProvider, PolymorphismSchema schema)
+			: base(ownerProvider, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom | SerializerCapabilities.UnpackTo)
+		{
+			if (typeof(T).GetIsValueType())
+			{
+				Throw.ValueTypeCannotBePolymorphic(typeof(T));
+			}
+
+			this._schema = schema.FilterSelf();
+		}
+
+		private ObjectSerializer GetActualTypeSerializer(Type actualType)
+		{
+			var result = this.ObjectSerializerProvider.GetSerializer(actualType, this._schema);
+			if (result == null)
+			{
+				Throw.CannotGetActualTypeSerializer(actualType);
+			}
+
+			return result!;
+		}
+
+		public sealed override void Serialize(ref SerializationOperationContext context, [AllowNull] T obj, IBufferWriter<byte> sink)
+		{
+			if (obj is null)
+			{
+				context.Encoder.EncodeNull(sink);
+				return;
+			}
+
+			TypeInfoEncoder.EncodeStart(ref context, sink, obj.GetType());
+			// T is ref type here, so boxing will not be occurred.
+			this.GetActualTypeSerializer(obj.GetType()).SerializeObject(ref context, obj, sink);
+			TypeInfoEncoder.EncodeEnd(ref context, sink);
+		}
+
+		[return: MaybeNull]
+		public sealed override T Deserialize(ref DeserializationOperationContext context, ref SequenceReader<byte> source)
+			=> TypeInfoEncoder.Decode(
+				ref context,
+				ref source,
+				(ref DeserializationOperationContext x, ref SequenceReader<byte> s) => TypeInfoEncoder.DecodeRuntimeTypeInfo(ref x, ref s, this._schema.TypeVerifier), // Lamda capture is more efficient.
+				(Type t, ref DeserializationOperationContext x, ref SequenceReader<byte> s) => (T)(this.GetActualTypeSerializer(t).DeserializeObject(ref x, ref s)!)
+			);
+
+		public sealed override bool DeserializeTo(ref DeserializationOperationContext context, ref SequenceReader<byte> source, T obj)
+			=> this.GetActualTypeSerializer(Ensure.NotNull(obj).GetType()).DeserializeObjectTo(ref context, ref source, obj);
+
+#if FEATURE_TAP
+
+		public sealed override ValueTask<T> DeserializeAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source)
+			=> TypeInfoEncoder.DecodeAsync(
+					context,
+					source,
+					(x, s) => TypeInfoEncoder.DecodeRuntimeTypeInfoAsync(x, s, this._schema.TypeVerifier), // Lamda capture is more efficient.
+					async (t, x, s) => ((T)await this.GetActualTypeSerializer(t).DeserializeObjectAsync(x, s).ConfigureAwait(false))!
+				);
+
+		public sealed override ValueTask<bool> DeserializeToAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, T obj)
+			=> this.GetActualTypeSerializer(Ensure.NotNull(obj).GetType()).DeserializeObjectToAsync(context, source, obj);
+
+#endif // FEATURE_TAP
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventArgs.cs b/src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventArgs.cs
new file mode 100644
index 000000000..2f615364f
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventArgs.cs
@@ -0,0 +1,33 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Represents event data of <see cref="SerializerProvider.ResolveObjectSerializer"/> event.
+	/// </summary>
+	public struct ResolveObjectSerializerEventArgs
+	{
+		public SerializerProvider Source { get; }
+		public Type TargetType { get; }
+		public PolymorphismSchema PolymorphismSchema { get; }
+
+		private ObjectSerializer? _serializer;
+
+		internal ObjectSerializer? GetSerializer() => this._serializer;
+
+		public void SetSerializer(ObjectSerializer serializer)
+			=> this._serializer = Ensure.NotNull(serializer);
+
+		internal ResolveObjectSerializerEventArgs(SerializerProvider source, Type targetType, PolymorphismSchema polymorphismSchema)
+		{
+			this.Source = source;
+			this.TargetType = targetType;
+			this.PolymorphismSchema = polymorphismSchema;
+			this._serializer = null;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventHandler.cs b/src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventHandler.cs
new file mode 100644
index 000000000..cc0009d25
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/ResolveObjectSerializerEventHandler.cs
@@ -0,0 +1,14 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines event handler delegate for <see cref="SerializerProvider.ResolveObjectSerializer"/> event.
+	/// </summary>
+	/// <param name="e">
+	///		A reference of <see cref="ResolveObjectSerializerEventArgs"/> which holds inputs and a result of the event handler.
+	///	</param>
+	public delegate void ResolveObjectSerializerEventHandler(ref ResolveObjectSerializerEventArgs e);
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializationCompatibilityOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/SerializationCompatibilityOptionsBuilder.cs
new file mode 100644
index 000000000..23c4021f5
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializationCompatibilityOptionsBuilder.cs
@@ -0,0 +1,215 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Configures compatibility options of the serialization runtime.
+	/// </summary>
+	/// <remarks>
+	///		These options should affect serializer behavior even if you disables runtime or ahead-of-time code generation.
+	/// </remarks>
+	public sealed class SerializationCompatibilityOptionsBuilder
+	{
+		private static readonly Func<Type, ISerializerGenerationOptions, bool>[] DefaultSerializableAnywayInterfaceDetectors = Array.Empty<Func<Type, ISerializerGenerationOptions, bool>>();
+
+		private static readonly Func<Type, ISerializerGenerationOptions, bool>[] DefaultDeserializableInterfaceDetectors = Array.Empty<Func<Type, ISerializerGenerationOptions, bool>>();
+
+		/// <summary>
+		///		Gets the value indicating whether array serialization method should use 1 bound order instead of default 0 bound order  for <see cref="MessagePackMemberAttribute.Id"/> or simular attribute properties.
+		/// </summary>
+		/// <value>
+		///		<c>true</c>, if the array serialization method should use 1 bound order; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		Using this value, you can switch between MessagePack for CLI and ProtoBuf.NET seamlessly.
+		/// </remarks>
+		public bool UsesOneBoundDataMemberOrder { get; private set; } = false;
+
+		/// <summary>
+		///		Gets the value indicating whether serialization runtime should serialize a type implementing <see cref="IEnumerable"/> as a normal type if a public <c>Add</c> method is not found
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if serialization runtime should serialize a type implementing <see cref="IEnumerable"/> as a normal type if a public <c>Add</c> method is not found; otherwise, <c>false</c>. The default is <c>true</c>.
+		/// </value>
+		/// <remarks>
+		///		Historically, MessagePack for CLI always tried to serialize any type that implemented <see cref="IEnumerable"/> as a collection, throwing an exception
+		///		if an <c>Add</c> method could not be found. However, for types that implement <see cref="IEnumerable"/> but don't have an <c>Add</c> method the generator will now
+		///		serialize the type as a non-collection type. To restore the old behavior for backwards compatibility, set this option to <c>false</c>.
+		/// </remarks>
+		public bool AllowsNonCollectionEnumerableTypes { get; private set; } = true;
+
+		/// <summary>
+		///		Gets the delegate which provides <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <value>
+		///		The delegate which provides <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		///		Note that 1st argument is attributes of the type, and 2nd argument is of the member.
+		///		If there are no attribute which is compatible to <see cref="MessagePackMemberAttribute"/>, the delegate must return <c>null</c>.
+		///		<c>null</c> means usage of default logic which treats <see cref="System.Runtime.Serialization.DataMemberAttribute" /> as <see cref="MessagePackMemberAttribute"/> 
+		///		only if the target type also marked with <see cref="System.Runtime.Serialization.DataContractAttribute" />.
+		///		In addition, <see cref="System.Runtime.Serialization.DataMemberAttribute.Order"/> will be treated as <see cref="MessagePackMemberAttribute.Id" />,
+		///		and <see cref="System.Runtime.Serialization.DataMemberAttribute.Name"/> will be treated as <see cref="MessagePackMemberAttribute.Name"/>.
+		/// </value>
+		/// <remarks>
+		///		This property is used for compatibility with other well known libraries.
+		/// </remarks>
+		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?>? MessagePackMemberAttributeCompatibilityProvider { get; set; }
+
+		/// <summary>
+		///		Gets the delegate which provides <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <value>
+		///		The delegate which provides <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		///		Note that 1st argument is attributes of the type, and 2nd argument is of the member.
+		///		If there are no attribute which is compatible to <see cref="MessagePackIgnoreAttribute"/>, the delegate must return <c>null</c>.
+		///		<c>null</c> means usage of default logic which treats <see cref="System.Runtime.Serialization.IgnoreDataMemberAttribute" /> as <see cref="MessagePackIgnoreAttribute"/>.
+		/// </value>
+		/// <remarks>
+		///		This property is used for compatibility with other well known libraries.
+		///		Currently, the <see cref="MessagePackIgnoreAttributeData"/> struct has no members, so non-null value means the member is ignored.
+		/// </remarks>
+		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackIgnoreAttributeData?>? IgnoringAttributeCompatibilityProvider { get; private set; }
+
+		// These members used by compatibility layer.
+#warning TODO: CompatiblityPackage:	typeof(IPackable).IsAssignableFrom(t) || typeof(IUnpackable).IsAssignableFrom(t) || (!o.WithAsync || typeof(IAsyncPackable).IsAssignableFrom(t) || typeof(IAsyncUnpackable).IsAssignableFrom(t))
+		internal IList<Func<Type, ISerializerGenerationOptions, bool>> SerializableAnywayInterfaceDetectors { get; } = new List<Func<Type, ISerializerGenerationOptions, bool>>(DefaultSerializableAnywayInterfaceDetectors);
+
+#warning TODO: CompatiblityPackage: typeof(IUnpackable).IsAssignableFrom(t) && (!o.WithAsync || typeof(IAsyncUnpackable).IsAssignable(t))
+		internal IList<Func<Type, ISerializerGenerationOptions, bool>> DeserializableInterfaceDetectors { get; } = new List<Func<Type, ISerializerGenerationOptions, bool>>(DefaultDeserializableInterfaceDetectors);
+
+		internal SerializationCompatibilityOptionsBuilder() { }
+
+		/// <summary>
+		///		Indicates using 1 bound order instead of 0 bound  for <see cref="MessagePackMemberAttribute.Id"/> or simular attribute properties.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		Using this value, you can switch between MessagePack for CLI and ProtoBuf.NET seamlessly.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder UseOneBoundDataMemberOrder()
+		{
+			this.UsesOneBoundDataMemberOrder = true;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates using 0 bound order for <see cref="MessagePackMemberAttribute.Id"/> or simular attribute properties.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="UsesOneBoundDataMemberOrder"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder UseZeroBoundDataMemberOrder()
+		{
+			this.UsesOneBoundDataMemberOrder = false;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates serialization runtime should NOT throw an exception for a type implementing <see cref="IEnumerable"/> and the type does not expose a public <c>Add</c> method.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="AllowsNonCollectionEnumerableTypes"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder AllowNonCollectionEnumerableTypes()
+		{
+			this.AllowsNonCollectionEnumerableTypes = true;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates serialization runtime should throw an exception for a type implementing <see cref="IEnumerable"/> and the type does not expose a public <c>Add</c> method.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		public SerializationCompatibilityOptionsBuilder DisallowNonCollectionEnumerableTypes()
+		{
+			this.AllowsNonCollectionEnumerableTypes = false;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates to use default logic to provide <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="MessagePackMemberAttributeCompatibilityProvider"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		///		The default logic treats <see cref="System.Runtime.Serialization.DataMemberAttribute" /> as <see cref="MessagePackMemberAttribute"/> 
+		///		only if the target type also marked with <see cref="System.Runtime.Serialization.DataContractAttribute" />.
+		///		In addition, <see cref="System.Runtime.Serialization.DataMemberAttribute.Order"/> will be treated as <see cref="MessagePackMemberAttribute.Id" />,
+		///		and <see cref="System.Runtime.Serialization.DataMemberAttribute.Name"/> will be treated as <see cref="MessagePackMemberAttribute.Name"/>.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder UseDefaultMessagePackMemberAttributeCompatibilityProvider()
+		{
+			this.MessagePackMemberAttributeCompatibilityProvider = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the delegate which provides <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <param name="value">
+		///		The delegate which provides <see cref="MessagePackMemberAttribute"/> compatible data from attributes for the member and its declaring type.
+		///		Note that 1st argument is attributes of the type, and 2nd argument is of the member.
+		///		If there are no attribute which is compatible to <see cref="MessagePackMemberAttribute"/>, the delegate must return <c>null</c>.
+		/// </param>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException"><paramref name="value"/> is <c>null</c>.</exception>
+		/// <remarks>
+		///		<see cref="MessagePackMemberAttributeCompatibilityProvider"/> property is used for compatibility with other well known libraries.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder UseCustomMessagePackMemberAttributeCompatibilityProvider(
+			Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?> value
+		)
+		{
+			this.MessagePackMemberAttributeCompatibilityProvider = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates to use default logic to provide <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="IgnoringAttributeCompatibilityProvider"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		///		The default logic treats <see cref="System.Runtime.Serialization.IgnoreDataMemberAttribute" /> as <see cref="MessagePackIgnoreAttribute"/>.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder UseDefaultIgnoringAttributeCompatibilityProvider()
+		{
+			this.IgnoringAttributeCompatibilityProvider = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the delegate which provides <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		/// </summary>
+		/// <param name="value">
+		///		The delegate which provides <see cref="MessagePackIgnoreAttribute"/> compatible data from attributes for the member and its declaring type.
+		///		Note that 1st argument is attributes of the type, and 2nd argument is of the member.
+		///		If there are no attribute which is compatible to <see cref="MessagePackIgnoreAttribute"/>, the delegate must return <c>null</c>.
+		/// </param>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException"><paramref name="value"/> is <c>null</c>.</exception>
+		/// <remarks>
+		///		<see cref="IgnoringAttributeCompatibilityProvider"/> property is used for compatibility with other well known libraries.
+		///		Currently, the <see cref="MessagePackIgnoreAttributeData"/> struct has no members, so non-null value means the member is ignored.
+		/// </remarks>
+		public SerializationCompatibilityOptionsBuilder UseCustomIgnoringAttributeCompatibilityProvider(
+			Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackIgnoreAttributeData?> value
+		)
+		{
+			this.IgnoringAttributeCompatibilityProvider = Ensure.NotNull(value);
+			return this;
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs b/src/MsgPack.Serialization/Serialization/SerializationOperationContext.cs
similarity index 95%
rename from src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
rename to src/MsgPack.Serialization/Serialization/SerializationOperationContext.cs
index c96a2e500..f6e8e17e8 100644
--- a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.cs
+++ b/src/MsgPack.Serialization/Serialization/SerializationOperationContext.cs
@@ -19,7 +19,7 @@ public struct SerializationOperationContext
 	{
 		public FormatEncoder Encoder { get; }
 		public SerializationOptions Options { get; }
-		public Encoding? StringEncoding => this.Options.StringEncoding;
+		public Encoding? StringEncoding => this.Options.DefaultStringEncoding;
 		public SerializationMethod SerializationMethod { get; }
 		public int CurrentDepth { get; private set; }
 		public CancellationToken CancellationToken { get; }
diff --git a/src/MsgPack.Abstraction/Serialization/SerializationOperationContext.tt b/src/MsgPack.Serialization/Serialization/SerializationOperationContext.tt
similarity index 100%
rename from src/MsgPack.Abstraction/Serialization/SerializationOperationContext.tt
rename to src/MsgPack.Serialization/Serialization/SerializationOperationContext.tt
diff --git a/src/MsgPack.Serialization/Serialization/SerializationOptions.cs b/src/MsgPack.Serialization/Serialization/SerializationOptions.cs
new file mode 100644
index 000000000..a1c89986a
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializationOptions.cs
@@ -0,0 +1,87 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System.Text;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines each serialization operations level options. This object is immutable.
+	/// </summary>
+	/// <seealso cref="SerializationOptionsBuilder"/>
+	public sealed class SerializationOptions
+	{
+		/// <summary>
+		///		Gets the default instance.
+		/// </summary>
+		/// <value>The default instance.</value>
+		public static SerializationOptions Default { get; } = new SerializationOptionsBuilder().Create();
+
+		/// <summary>
+		///		Gets the maximum depth of serialized object tree.
+		/// </summary>
+		/// <value>
+		///		The maximum depth of serialized object tree. Default is <c>100</c>.
+		/// </value>
+		public int MaxDepth { get; }
+
+		/// <summary>
+		///		Gets the default string encoding for string members or map keys which are not specified explicitly.
+		/// </summary>
+		/// <value>
+		///		The default string encoding for string members or map keys which are not specified explicitly.
+		///		Default value is <c>null</c>, which means using default encoding of underlying codec.
+		/// </value>
+		public Encoding? DefaultStringEncoding { get; }
+
+		// (Specified by Attribute [future]) > Type Default > This > FormatDefault
+		/// <summary>
+		///		Gets the preferred <see cref="SerializationMethod"/> which will be used members which serialization methods are not derived from their attributes nor member types.  
+		/// </summary>
+		/// <value>
+		///		The preferred <see cref="SerializationMethod"/> which will be used members which serialization methods are not derived from their attributes nor member types.  
+		///		Default is <c>null</c>, which means using default method of underlying codec.
+		/// </value>
+		public SerializationMethod? PreferredSerializationMethod { get; }
+
+		/// <summary>
+		///		Gets a default value of object serialization method for specified codec.
+		/// </summary>
+		/// <param name="codecFeatures">A feature of the codec.</param>
+		/// <returns>
+		///		<see cref="SerializationMethod"/> for specified codec features.
+		///		If an any value is set via builder object, the value will be returned,
+		///		else returns <see cref="CodecFeatures.PreferredObjectSerializationMethod"/>.
+		/// </returns>
+		public SerializationMethod GetDefaultObjectSerializationMethod(CodecFeatures codecFeatures)
+		{
+			Ensure.NotNull(codecFeatures);
+			var result = this.PreferredSerializationMethod ?? codecFeatures.PreferredObjectSerializationMethod;
+			var isAvailable =
+				result switch
+				{
+					SerializationMethod.Array => (codecFeatures.AvailableSerializationMethods & AvailableSerializationMethods.Array) != 0,
+					_ /* Map */ => (codecFeatures.AvailableSerializationMethods & AvailableSerializationMethods.Map) != 0,
+				};
+			if (!isAvailable)
+			{
+				Throw.UnavailableMethod(codecFeatures.Name, result);
+			}
+
+			return result;
+		}
+
+
+
+		internal SerializationOptions(
+			SerializationOptionsBuilder builder
+		)
+		{
+			this.MaxDepth = builder.MaxDepth;
+			this.DefaultStringEncoding = builder.DefaultStringEncoding;
+			this.PreferredSerializationMethod = builder.PreferredSerializationMethod;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializationOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/SerializationOptionsBuilder.cs
new file mode 100644
index 000000000..36ca40cca
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializationOptionsBuilder.cs
@@ -0,0 +1,364 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using MsgPack.Internal;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		A builder object for <see cref="SerializationOptions"/> which defines options for each serialization operations.
+	/// </summary>
+	/// <seealso cref="SerializationOptions"/>
+	public sealed class SerializationOptionsBuilder
+	{
+		/// <summary>
+		///		Gets the maximum depth of the serialized object tree.
+		/// </summary>
+		/// <value>
+		///		The maximum depth of the serialized object tree. Default is <c>100</c>.
+		/// </value>
+		public int MaxDepth { get; private set; } = OptionsDefaults.MaxDepth;
+
+		/// <summary>
+		///		Gets the default string encoding for string members or map keys which are not specified explicitly.
+		/// </summary>
+		/// <value>
+		///		The default string encoding for string members or map keys which are not specified explicitly.
+		///		Default value is <c>null</c>, which means using default encoding of underlying codec.
+		/// </value>
+		public Encoding? DefaultStringEncoding { get; private set; }
+
+		/// <summary>
+		///		Gets the preferred <see cref="SerializationMethod"/> which will be used members which serialization methods are not derived from their attributes nor member types.  
+		/// </summary>
+		/// <value>
+		///		The preferred <see cref="SerializationMethod"/> which will be used members which serialization methods are not derived from their attributes nor member types.  
+		///		Default is <c>null</c>, which means using default method of underlying codec.
+		/// </value>
+		public SerializationMethod? PreferredSerializationMethod { get; private set; } = OptionsDefaults.PreferredSerializationMethod;
+
+#warning TODO:
+		public ExtensionTypeMapping ExtensionTypeMapping { get; } = new ExtensionTypeMapping();
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="SerializationOptionsBuilder"/> object.
+		/// </summary>
+		public SerializationOptionsBuilder() { }
+
+		/// <summary>
+		///		Creates a new instance of <see cref="SerializationOptions"/> object from current state of this instance.
+		/// </summary>
+		/// <returns>A new instance of <see cref="SerializationOptions"/> object.</returns>
+		public SerializationOptions Create()
+			=> new SerializationOptions(this);
+
+		/// <summary>
+		///		Indicates the maximum depth of the serialized object tree to the default value.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="MaxDepth"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializationOptionsBuilder UseDefaultMaxDepth()
+			=> this.UseMaxDepth(OptionsDefaults.MaxDepth);
+
+		/// <summary>
+		///		Sets the maximum depth of the serialized object tree.
+		/// </summary>
+		/// <param name="value">A value to be set.</param>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException">
+		///		<paramref name="value"/> is less than or equal to <c>0</c>, or exceeds <c>0x7FEFFFFF</c>.
+		/// </exception>
+		public SerializationOptionsBuilder UseMaxDepth(int value)
+		{
+			this.MaxDepth = Ensure.IsBetween(value, 1, OptionsDefaults.MaxMultiByteCollectionLength); ;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the default string encoding for string members or map keys to use default encoding of the codec.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="DefaultStringEncoding"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializationOptionsBuilder UseCodecDefaultStringEncoding()
+		{
+			this.DefaultStringEncoding = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the default string encoding for string members or map keys which are not specified explicitly.
+		/// </summary>
+		/// <param name="value">An <see cref="Encoding"/> to use encode/decode string value.</param>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentNullException"><paramref name="value"/> is <c>null</c>.</exception>
+		/// <remarks>
+		///		This method should be called only when you needs to interoperability with system which uses non-default encoding for the codec.
+		/// </remarks>
+		public SerializationOptionsBuilder UseCustomDefaultStringEncoding(Encoding value)
+		{
+			this.DefaultStringEncoding = Ensure.NotNull(value);
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates the preferred <see cref="SerializationMethod"/> to use codec's default.
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="PreferredSerializationMethod"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializationOptionsBuilder UseCodecDefaultPreferredSerializationMethod()
+		{
+			this.PreferredSerializationMethod = null;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the preferred <see cref="SerializationMethod"/> which will be used members which serialization methods are not derived from their attributes nor member types.  
+		/// </summary>
+		/// <returns>This <see cref="SerializationOptionsBuilder"/> instance.</returns>
+		/// <exception cref="System.ArgumentOutOfRangeException"><paramref name="value"/> is not known <see cref="SerializationMethod"/> value.</exception>
+		/// <remarks>
+		///		Note that preferred <see cref="SerializationMethod"/> may cause error when the codec does not support the value.
+		/// </remarks>
+		public SerializationOptionsBuilder UseCustomPreferredSerializationMethod(SerializationMethod value)
+		{
+			switch (value)
+			{
+				case SerializationMethod.Array:
+				case SerializationMethod.Map:
+				{
+					break;
+				}
+				default:
+				{
+					Throw.UndefinedEnumMember(value);
+					break; // never
+				}
+			}
+			this.PreferredSerializationMethod = value;
+			return this;
+		}
+	}
+
+	/// <summary>
+	///		Implements mapping table between known ext type codes and names.
+	/// </summary>
+	/// <remarks>
+	///		Well-known (pre-defined) ext type names are defined in <c>KnownExtensionTypeNames</c>, and their default mapped codes are found in <c>KnownExtensionTypeCodes</c>.
+	///		They should be defined in codec assemblies if available.
+	/// </remarks>
+	/// <threadsafety instance="true" static="true" />
+	public sealed class ExtensionTypeCodeMapping : IEnumerable<KeyValuePair<string, ExtensionType>>
+	{
+		private readonly object _syncRoot;
+		private readonly Dictionary<string, ExtensionType> _index;
+		private readonly Dictionary<ExtensionType, string> _types;
+
+		/// <summary>
+		///		Gets a mapped byte to the specified ext type name.
+		/// </summary>
+		/// <param name="name">The name of the ext type.</param>
+		/// <returns>
+		///		The <see cref="ExtensionType"/> for specified ext type in the current context.
+		/// </returns>
+		/// <exception cref="ArgumentNullException"><paramref name="name"/> is <c>null</c>.</exception>
+		/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
+		/// <exception cref="KeyNotFoundException"><paramref name="name"/> is not registered as known ext type name.</exception>
+		public ExtensionType this[string name]
+		{
+			get
+			{
+				ValidateName(name);
+
+				lock (this._syncRoot)
+				{
+					if (!this._index.TryGetValue(name, out var code))
+					{
+						Throw.ExtensionTypeKeyNotFound(name);
+						throw new KeyNotFoundException(
+							String.Format(CultureInfo.CurrentCulture, "Ext type '{0}' is not found.", name)
+						);
+					}
+
+					return code;
+				}
+			}
+		}
+
+		internal ExtensionTypeCodeMapping()
+		{
+			this._syncRoot = new object();
+			this._index = new Dictionary<string, ExtensionType>();
+			this._types = new Dictionary<ExtensionType, string>();
+		}
+
+		/// <summary>
+		///		Adds the known ext type mapping.
+		/// </summary>
+		/// <param name="name">The name of the ext type.</param>
+		/// <param name="typeCode">The ext type code to be mapped.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="name"/> AND <paramref name="typeCode"/> were not registered and then newly registered; <c>false</c>, otherwise.
+		/// </returns>
+		/// <exception cref="ArgumentNullException"><paramref name="name"/> is <c>null</c>.</exception>
+		/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
+		/// <exception cref="ArgumentOutOfRangeException"><paramref name="typeCode"/> is greater than 0x7F.</exception>
+		public bool Add(string name, byte typeCode)
+		{
+			ValidateName(name);
+			ValidateTypeCode(typeCode);
+			return this.AddInternal(name, typeCode);
+		}
+
+		private bool AddInternal(string name, byte typeCode)
+		{
+			lock (this._syncRoot)
+			{
+				try
+				{
+					this._types.Add(typeCode, name);
+				}
+				catch (ArgumentException)
+				{
+					return false;
+				}
+
+				this._index[name] = typeCode;
+				return true;
+			}
+		}
+
+		/// <summary>
+		///		Removes the mapping with specified name.
+		/// </summary>
+		/// <param name="name">The name of the ext type.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="name"/> was registered and has been removed successfully; <c>false</c>, otherwise.
+		/// </returns>
+		/// <exception cref="ArgumentNullException"><paramref name="name"/> is <c>null</c>.</exception>
+		/// <exception cref="ArgumentException"><paramref name="name"/> is empty.</exception>
+		public bool Remove(string name)
+		{
+			ValidateName(name);
+
+			lock (this._syncRoot)
+			{
+				byte typeCode;
+				if (!this._index.TryGetValue(name, out typeCode))
+				{
+					return false;
+				}
+
+				this.RemoveCore(name, typeCode);
+				return true;
+			}
+		}
+
+		/// <summary>
+		///		Removes the mapping with specified code.
+		/// </summary>
+		/// <param name="typeCode">The type code of the ext type.</param>
+		/// <returns>
+		///		<c>true</c> if <paramref name="typeCode"/> was registered and has been removed successfully; <c>false</c>, otherwise.
+		/// </returns>
+		/// <exception cref="ArgumentOutOfRangeException"><paramref name="typeCode"/> is greater than 0x7F.</exception>
+		public bool Remove(byte typeCode)
+		{
+			ValidateTypeCode(typeCode);
+
+			lock (this._syncRoot)
+			{
+				string name;
+				if (!this._types.TryGetValue(typeCode, out name))
+				{
+					return false;
+				}
+
+				this.RemoveCore(name, typeCode);
+				return true;
+			}
+		}
+
+		private void RemoveCore(string name, byte typeCode)
+		{
+#if DEBUG && NET45
+			Contract.Assert( Monitor.IsEntered( this._syncRoot ) );
+#endif // DEBUG && NET45
+			var shouldBeTrue = this._types.Remove(typeCode);
+			Contract.Assert(shouldBeTrue);
+			shouldBeTrue = this._index.Remove(name);
+			Contract.Assert(shouldBeTrue);
+		}
+
+		/// <summary>
+		///		Clears all mappings.
+		/// </summary>
+		public void Clear()
+		{
+			lock (this._syncRoot)
+			{
+				this._types.Clear();
+				this._index.Clear();
+			}
+		}
+
+		/// <summary>
+		///		Returns an enumerator that iterates through the collection.
+		/// </summary>
+		/// <returns>
+		///		A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.
+		/// </returns>
+		/// <remarks>
+		///		This method causes internal collection copying, so this makes O(n) time.
+		/// </remarks>
+		public IEnumerator<KeyValuePair<string, byte>> GetEnumerator()
+		{
+			List<KeyValuePair<string, byte>> list;
+			lock (this._syncRoot)
+			{
+				list = this._index.ToList();
+			}
+
+			return list.GetEnumerator();
+		}
+
+		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+		{
+			return this.GetEnumerator();
+		}
+
+		private static void ValidateName(string name)
+		{
+			if (name == null)
+			{
+				throw new ArgumentNullException("name");
+			}
+
+			if (name.Length == 0)
+			{
+				throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "A parameter cannot be empty."), "name");
+			}
+		}
+
+		private static void ValidateTypeCode(byte typeCode)
+		{
+			if (typeCode > 0x7F)
+			{
+				throw new ArgumentOutOfRangeException("typeCode", "Ext type code must be between 0 and 0x7F.");
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer.cs b/src/MsgPack.Serialization/Serialization/Serializer.cs
similarity index 65%
rename from src/MsgPack.Abstraction/Serialization/Serializer.cs
rename to src/MsgPack.Serialization/Serialization/Serializer.cs
index c43c4e611..d5458b27b 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer.cs
+++ b/src/MsgPack.Serialization/Serialization/Serializer.cs
@@ -12,6 +12,8 @@ namespace MsgPack.Serialization
 {
 	public abstract class Serializer
 	{
+		public abstract SerializerCapabilities Capabilities { get; }
+
 		public abstract void SerializeObject(object? obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default);
 
 		public abstract ReadOnlyMemory<byte> SerializeObject(object? obj, CancellationToken cancellationToken = default);
@@ -25,5 +27,13 @@ public abstract class Serializer
 		public abstract object? DeserializeObject(ref ReadOnlyMemory<byte> memorySource, CancellationToken cancellationToken = default);
 
 		public abstract ValueTask<object?> DeserializeObjectAsync(Stream streamSource, CancellationToken cancellationToken = default);
+
+		public abstract bool DeserializeToObject(ref SequenceReader<byte> reader, object destination, CancellationToken cancellationToken = default);
+
+		public abstract bool DeserializeToObject(ref ReadOnlySequence<byte> source, object destination, CancellationToken cancellationToken = default);
+
+		public abstract bool DeserializeToObject(ref ReadOnlyMemory<byte> memorySource, object destination, CancellationToken cancellationToken = default);
+
+		public abstract ValueTask<bool> DeserializeToObjectAsync(Stream streamSource, object destination, CancellationToken cancellationToken = default);
 	}
 }
diff --git a/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs b/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs
index 03092fc25..20f7719d5 100644
--- a/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs
+++ b/src/MsgPack.Serialization/Serialization/SerializerBuilder.cs
@@ -1,11 +1,55 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
 // This file is licensed under Apache2 license.
 // See the LICENSE in the project root for more information.
 
-namespace MsgPack.Serialization.ReflectionSerializers
+using System;
+
+namespace MsgPack.Serialization
 {
 	internal abstract class SerializerBuilder
 	{
-		public abstract ObjectSerializer<T> Build<T>(ObjectSerializationContext context, SerializationTarget target);
+		public abstract ObjectSerializer BuildObjectSerializer(Type targetType, IObjectSerializerProvider owningProvider, in SerializationTarget target, ISerializerGenerationOptions options);
+
+		public abstract ObjectSerializer BuildTupleSerializer(Type targetType, IObjectSerializerProvider owningProvider, in SerializationTarget target, ISerializerGenerationOptions options);
+	}
+
+	internal sealed class SerializerBuilderRegistry
+	{
+		public static SerializerBuilderRegistry Instance
+		{
+			get;
+#if DEBUG
+			private set;
+#endif
+		} = new SerializerBuilderRegistry();
+
+#if DEBUG
+		public static void DebugResetInstance()
+			=> Instance = new SerializerBuilderRegistry();
+#endif // DEBUG
+
+		private SerializerBuilder? _forSourceCodeGeneration;
+		private SerializerBuilder? _forRuntimeCodeGeneration;
+		private SerializerBuilder? _forReflection;
+
+		private SerializerBuilderRegistry() { }
+
+		public void RegisterForSourceCodeGeneration(SerializerBuilder builder)
+			=> this._forSourceCodeGeneration = builder;
+
+		public void RegisterForRuntimeCodeGeneration(SerializerBuilder builder)
+			=> this._forRuntimeCodeGeneration = builder;
+
+		public void RegisterForReflection(SerializerBuilder builder)
+			=> this._forReflection = builder;
+
+		public SerializerBuilder GetForSourceCodeGeneration()
+			=> this._forSourceCodeGeneration ?? Throw.ForSourceCodeGenerationNotRegistered();
+
+		public SerializerBuilder GetForRuntimeCodeGeneration()
+			=> this._forRuntimeCodeGeneration ?? Throw.ForRuntimeCodeGenerationNotRegistered();
+
+		public SerializerBuilder GetForReflection()
+			=> this._forReflection ?? Throw.ForReflectionNotRegistered();
 	}
 }
diff --git a/src/MsgPack.Serialization/Serialization/SerializerFactory.cs b/src/MsgPack.Serialization/Serialization/SerializerFactory.cs
new file mode 100644
index 000000000..774af34b4
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerFactory.cs
@@ -0,0 +1,96 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Providers generic serializer instance factory with reflection.
+	/// </summary>
+	internal static partial class SerializerFactory
+	{
+		private static readonly Type[] StandardObjectSerializerConstructorParameterTypes = { typeof(SerializerProvider) };
+
+		public static Serializer CreateSerializer(
+			Type targetType,
+			CodecProvider codecProvider,
+			ObjectSerializer underlying,
+			SerializationOptions serializationOptions,
+			DeserializationOptions deserializationOptions
+		)
+			// We cannot use ArrayPool<T> here because it does not guarntee returning array length, but Reflection APIs relies it.
+			=> typeof(DefaultSerializer<>)
+				.MakeGenericType(targetType)
+				.GetConstructor(
+					new[]
+					{
+						typeof(CodecProvider),
+						typeof(ObjectSerializer<>).MakeGenericType(targetType),
+						typeof(SerializationOptions),
+						typeof(DeserializationOptions)
+					}
+				)!.InvokePreservingExceptionType<Serializer>(codecProvider, underlying, serializationOptions, deserializationOptions);
+
+		public static ObjectSerializer CreateObjectSerializer(Type genericSerializerType, Type targetType, SerializerProvider provider)
+			// We cannot use ArrayPool<T> here because it does not guarntee returning array length, but Reflection APIs relies it.
+			=> genericSerializerType
+				.MakeGenericType(targetType)
+#warning TODO: ArrayCache(1,2,3)
+				.GetRequiredConstructor(StandardObjectSerializerConstructorParameterTypes)
+				.InvokePreservingExceptionType<ObjectSerializer>(provider);
+
+		public static ObjectSerializer CreateObjectSerializer<TArg>(Type genericSerializerType, Type targetType, SerializerProvider provider, TArg arg)
+			// We cannot use ArrayPool<T> here because it does not guarntee returning array length, but Reflection APIs relies it.
+			=> genericSerializerType
+				.MakeGenericType(targetType)
+				.GetRequiredConstructor(typeof(SerializerProvider), typeof(TArg))
+				.InvokePreservingExceptionType<ObjectSerializer>(provider, arg);
+
+		public static ObjectSerializer CreateObjectSerializer<TArg1, TArg2>(Type genericSerializerType, Type targetType, SerializerProvider provider, TArg1 arg1, TArg2 arg2)
+			// We cannot use ArrayPool<T> here because it does not guarntee returning array length, but Reflection APIs relies it.
+			=> genericSerializerType
+				.MakeGenericType(targetType)
+				.GetRequiredConstructor(typeof(SerializerProvider), typeof(TArg1), typeof(TArg2))
+				.InvokePreservingExceptionType<ObjectSerializer>(provider, arg1, arg2);
+
+		public static ObjectSerializer CreateNullableObjectSerializer(Type targetType, Type underlyingType, SerializerProvider provider, ObjectSerializer underlyingSerializer)
+			=> typeof(NullableObjectSerializer<>)
+				.MakeGenericType(targetType)
+				.GetRequiredConstructor(typeof(SerializerProvider), typeof(ObjectSerializer<>).MakeGenericType(underlyingType))
+				.InvokePreservingExceptionType<ObjectSerializer>(provider, underlyingSerializer);
+
+		public static ObjectSerializer CreateEnumSerializer(
+			Type targetType, 
+			SerializerProvider provider, 
+			EnumSerializationMethod? method, 
+			NameMapper nameMapper,
+			object serializationNameMapping,
+			object deserializationNameMapping
+		)
+		{
+			Debug.Assert(targetType.GetIsEnum());
+
+			return
+				GetEnumSerializerGenericTypeDefinition(Enum.GetUnderlyingType(targetType))
+				.MakeGenericType(targetType)
+				.GetRequiredConstructor(
+					typeof(SerializerProvider),
+					typeof(EnumSerializationMethod?),
+					typeof(NameMapper),
+					typeof(Dictionary<,>).MakeGenericType(targetType, typeof(string)),
+					typeof(Dictionary<,>).MakeGenericType(typeof(string), targetType)
+				).InvokePreservingExceptionType<ObjectSerializer>(
+					provider,
+					method,
+					nameMapper,
+					serializationNameMapping,
+					deserializationNameMapping
+				);
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs b/src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs
deleted file mode 100644
index 820c44f71..000000000
--- a/src/MsgPack.Serialization/Serialization/SerializerGenerationOptions.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright (c) FUJIWARA, Yusuke and all contributors.
-// This file is licensed under Apache2 license.
-// See the LICENSE in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-
-namespace MsgPack.Serialization
-{
-	public readonly struct MessagePackMemberAttributeData
-	{
-		public int? Id { get; }
-		public string? Name { get; }
-
-		public MessagePackMemberAttributeData(int? id, string? name)
-		{
-			this.Id = id == null ? id : Ensure.IsNotLessThan(id.GetValueOrDefault(), 0, nameof(id));
-			this.Name = name;
-		}
-	}
-
-	internal sealed class SerializerGenerationOptions
-	{
-		public bool DisablesPrivilegedAccess { get; }
-		public bool OneBoundDataMemberOrder { get; }
-		public bool AllowsAsymmetricSerializer { get; }
-		public ISet<string> IgnoreAttributeTypeNames { get; }
-		public Func<Type, SerializerGenerationOptions, bool> SerializableAnywayInterfaceDetector { get; } 
-		public Func<Type, SerializerGenerationOptions, bool> DeserializableInterfaceDetector { get; }
-		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?>? MessagePackMemberAttributeCompatibilityProvider { get; }
-		public IReadOnlyDictionary<Type, IEnumerable<string>> IgnoringMembers { get; }
-	}
-
-	public sealed class SerializerGenerationOptionsBuilder
-	{
-		private static readonly string[] DefaultIgnoreAttributeTypeNames =
-			new[]
-			{
-				"MsgPack.Serialization.MessagePackIgnoreAttribute",
-				"System.Runtime.Serialization.IgnoreDataMemberAttribute"
-			};
-
-#warning TODO: CompatiblityPackage:	typeof(IPackable).IsAssignableFrom(t) || typeof(IUnpackable).IsAssignableFrom(t) || (!o.WithAsync || typeof(IAsyncPackable).IsAssignableFrom(t) || typeof(IAsyncUnpackable).IsAssignableFrom(t))
-		private static readonly Func<Type, SerializerGenerationOptions, bool>[] DefaultSerializableAnywayInterfaceDetectors = Array.Empty<Func<Type, SerializerGenerationOptions, bool>>();
-
-#warning TODO: CompatiblityPackage: typeof(IUnpackable).IsAssignableFrom(t) && (!o.WithAsync || typeof(IAsyncUnpackable).IsAssignable(t))
-		private static readonly Func<Type, SerializerGenerationOptions, bool>[] DefaultDeserializableInterfaceDetectors = Array.Empty<Func<Type, SerializerGenerationOptions, bool>>();
-
-		internal IList<Func<Type, SerializerGenerationOptions, bool>> SerializableAnywayInterfaceDetectors { get; } = new List<Func<Type, SerializerGenerationOptions, bool>>(DefaultSerializableAnywayInterfaceDetectors);
-		internal IList<Func<Type, SerializerGenerationOptions, bool>> DeserializableInterfaceDetectors { get; } = new List<Func<Type, SerializerGenerationOptions, bool>>(DefaultDeserializableInterfaceDetectors);
-
-		public bool DisablesPrivilegedAccess { get; set; }
-		public bool OneBoundDataMemberOrder { get; set; }
-		public bool AllowsAsymmetricSerializer { get; set; }
-		public ISet<string> IgnoreAttributeTypeNames { get; } = new HashSet<string>(DefaultIgnoreAttributeTypeNames, StringComparer.Ordinal);
-		public Func<IEnumerable<CustomAttributeData>, IEnumerable<CustomAttributeData>, MessagePackMemberAttributeData?>? MessagePackMemberAttributeCompatibilityProvider { get; set; }
-	}
-}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerGenerationOptionsBuilder.cs b/src/MsgPack.Serialization/Serialization/SerializerGenerationOptionsBuilder.cs
new file mode 100644
index 000000000..4407e726b
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerGenerationOptionsBuilder.cs
@@ -0,0 +1,352 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.ComponentModel;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		A builder object for options which affect serializer generation and generated serializer behavior.
+	/// </summary>
+	public sealed class SerializerGenerationOptionsBuilder
+	{
+		// Following fields are initialized lazily to avoid unnecessary memory allocation
+		// because there are no configurations needed in usual cases.
+
+		private BindingOptionsBuilder? _bindingOptionsBuilder;
+
+		private SerializationCompatibilityOptionsBuilder? _compatibilityOptionsBuilder;
+
+		private DefaultConcreteTypeRepositoryBuilder? _defaultCollectionTypesBuilder;
+
+		private DictionarySerializationOptionsBuilder? _dictionaryOptionsBuilder;
+
+		private EnumSerializationOptionsBuilder? _enumOptionsBuilder;
+
+		private DateTimeSerializationOptionsBuilder? _dateTimeOptionsBuilder;
+
+		private SerializationOptionsBuilder? _serializationOptionsBuilder;
+
+		private DeserializationOptionsBuilder? _deserializationOptionsBuilder;
+
+		/// <summary>
+		///		Gets the value indicating whether the serializer runtime allows serialization even if feature complete serializer cannot be generated due to lack of some requirement.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if the serializer runtime allows serialization even if feature complete serializer cannot be generated due to lack of some requirement; otherwise, <c>false</c>. The default is <c>false</c>.
+		/// </value>
+		/// <remarks>
+		///		Currently, the lack of constructor (default or parameterized) or lack of settable members are considerd as "cannot generate feature complete serializer".
+		///		Therefore, you can get serialization only serializer if this property is set to <c>true</c>.
+		///		This is useful for logging, telemetry injestion, or so.
+		///		You can investigate serializer capability via <see cref="Serializer.Capabilities"/> property.
+		/// </remarks>
+		public bool AllowsAsymmetricSerializer { get; private set; }
+
+		/// <summary>
+		///		Gets the value which indicates whether on-the-fly runtime code generation is disabled.
+		/// </summary>
+		/// <value>
+		///		<c>true</c> if runtime code generation (via <c>System.Reflection.Emit)</c>) is disabled; <c>false</c>, otherwise.
+		/// </value>
+		/// <remarks>
+		///		If this value set to <c>false</c>, reflection based serializers will be used if they are activated.
+		///		If it was not activated, only pre-registered serializers will be used.
+		///		Typically, this value will be used for debugging purposes.
+		/// </remarks>
+		public bool IsRuntimeCodeGenerationDisabled { get; private set; }
+
+		private const string DefaultRuntimeCodeGenerationAssemblyName = "MsgPack.Serialization.EmittingSerializers.GeneratedSerealizers";
+
+		/// <summary>
+		///		Gets the name of the assembly which holds generated serializer types.
+		/// </summary>
+		/// <value>
+		///		The name of the assembly which holds generated serializer types.
+		///		Default value is <c>MsgPack.Serialization.EmittingSerializers.GeneratedSerealizers</c>.
+		/// </value>
+		public string RuntimeCodeGenerationAssemblyName { get; private set; } = DefaultRuntimeCodeGenerationAssemblyName;
+
+		/// <summary>
+		///		This is an advanced option.
+		///		Gets the value which indicates runtime code generation flavor.
+		/// </summary>
+		/// <value>
+		///		The value which indicates runtime code generation flavor.
+		/// </value>
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public SerializationMethodGeneratorOption RuntimeGeneratedCodeOption { get; private set; } = SerializationMethodGeneratorOption.Fast;
+
+		/// <summary>
+		///		Indicates serialization runtime should allow serialization even if feature complete serializer cannot be generated due to lack of some requirement.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		You can investigate serializer capability via <see cref="Serializer.Capabilities"/> property.
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder AllowAsymmetricSerializer()
+		{
+			this.AllowsAsymmetricSerializer = true;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates serialization runtime should NOT allow serialization even if feature complete serializer cannot be generated due to lack of some requirement.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="AllowsAsymmetricSerializer"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder DisallowAsymmetricSerializer()
+		{
+			this.AllowsAsymmetricSerializer = false;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates serialization runtime can use runtime code generation for serializers.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="IsRuntimeCodeGenerationDisabled"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder EnableRuntimeCodeGeneration()
+		{
+			this.IsRuntimeCodeGenerationDisabled = false;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates serialization runtime cannot use runtime code generation for serializers.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		In some platform such as iOS prohibit JIT (Just In Time compilation), it also disable runtime code generation.
+		///		If your solution have to run on such environment, disabling runtime code generation help code consistency and stability.
+		///		That means when you forget to register pre-generated serializers, you will get an exception instead of on-the-fly serializer generation.
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder DisableRuntimeCodeGeneration()
+		{
+			this.IsRuntimeCodeGenerationDisabled = true;
+			return this;
+		}
+
+		/// <summary>
+		///		Indicates serialization runtime uses default assembly name for the assembly which will contain all generated serializer types.
+		/// </summary>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		This method resets <see cref="RuntimeCodeGenerationAssemblyName"/> to default state.
+		///		It is not required to call this method normally, but you can use this method to clarify option settings.
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder UseDefaultRuntimeCodeGenerationAssemblyName()
+		{
+			this.RuntimeCodeGenerationAssemblyName = DefaultRuntimeCodeGenerationAssemblyName;
+			return this;
+		}
+
+		/// <summary>
+		///		Sets the name of the assembly which holds generated serializer types.
+		/// </summary>
+		/// <param name="value">
+		///		The name of the assembly which holds generated serializer types.
+		///		Default value is <c>MsgPack.Serialization.EmittingSerializers.GeneratedSerealizers</c>.
+		/// </param>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="value"/> is <c>null</c>.
+		/// </exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="value"/> is empty string, or contains white spaces only.
+		/// </exception>
+		/// <remarks>
+		///		You should use this method when you depends on <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> in 
+		///		the assembly which defines your non public target types.
+		///		In such case, you must mark that assembly with <see cref="System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> which accepts the assembly name specified to this property.
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder UseCustomRuntimeCodeGenerationAssemblyName(string value)
+		{
+			this.RuntimeCodeGenerationAssemblyName = Ensure.NotBlank(value);
+			return this;
+		}
+
+		/// <summary>
+		///		This is an advanced option.
+		///		Sets the value which indicates runtime code generation flavor.
+		/// </summary>
+		/// <param name="value">
+		///		The value which indicates runtime code generation flavor.
+		/// </param>
+		/// <returns>This <see cref="SerializationCompatibilityOptionsBuilder"/> instance.</returns>
+		/// <exception cref="ArgumentOutOfRangeException">
+		///		<paramref name="value"/> is not known <see cref="SerializationMethodGeneratorOption"/> value.
+		/// </exception>
+		[EditorBrowsable(EditorBrowsableState.Never)]
+		public SerializerGenerationOptionsBuilder TweakRuntimeGeneratedCodeOption(SerializationMethodGeneratorOption value)
+		{
+			switch (value)
+			{
+				case SerializationMethodGeneratorOption.CanCollect:
+				case SerializationMethodGeneratorOption.CanDump:
+				case SerializationMethodGeneratorOption.Fast:
+				{
+					this.RuntimeGeneratedCodeOption = value;
+					break;
+				}
+				default:
+				{
+					Throw.UndefinedEnumMember(value);
+					break; // never
+				}
+			}
+
+			return this;
+		}
+
+		/// <summary>
+		///		Initializes a new instance of <see cref="SerializerGenerationOptionsBuilder"/> object.
+		/// </summary>
+		public SerializerGenerationOptionsBuilder() { }
+
+		/// <summary>
+		///		Configures binding options of target members.
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="BindingOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureBindingOptions(Action<BindingOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._bindingOptionsBuilder ??= new BindingOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal IBindingOptions BuildBindngOptions()
+			=> new ImmutableBindingOptions(this._bindingOptionsBuilder ?? BindingOptionsBuilder.Default);
+
+		/// <summary>
+		///		Configures compatibility options of serialization runtime.
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="SerializationCompatibilityOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		/// <remarks>
+		///		A term 'compatibility' has 2 meanings:
+		///		<list type="number">
+		///			<item>Backward compatibility for old design.</item>
+		///			<item>User code compatibility for other wellknown libraries.</item>
+		///		</list>
+		/// </remarks>
+		public SerializerGenerationOptionsBuilder ConfigureCompatibilityOptions(Action<SerializationCompatibilityOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._compatibilityOptionsBuilder ??= new SerializationCompatibilityOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal ISerializationCompatibilityOptions BuildCompatibilityOptions()
+			=> this._compatibilityOptionsBuilder == null ? ImmutableSerializationCompatibilityOptions.Default : new ImmutableSerializationCompatibilityOptions(this._compatibilityOptionsBuilder);
+
+		/// <summary>
+		///		Configures the repository of known concrete collection types for abstract collection types on deserialization. 
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="DefaultConcreteTypeRepositoryBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureDefaultCollectionType(Action<DefaultConcreteTypeRepositoryBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._defaultCollectionTypesBuilder ??= new DefaultConcreteTypeRepositoryBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal IDefaultConcreteTypeRepository BuildDefaultCollectionTypes()
+			=> this._defaultCollectionTypesBuilder == null ? ImmutableDefaultConcreteTypeRepository.Default : this._defaultCollectionTypesBuilder.Build();
+
+		/// <summary>
+		///		Configures enum serialization options. 
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="EnumSerializationOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureEnumSerializationOptions(Action<EnumSerializationOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._enumOptionsBuilder ??= new EnumSerializationOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal IEnumSerializationOptions BuildEnumOptions()
+			=> new ImmutableEnumSerializationOptions(this._enumOptionsBuilder ?? EnumSerializationOptionsBuilder.Default);
+
+		/// <summary>
+		///		Configures <see cref="DateTime"/> and similar types serialization behavior
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="DateTimeSerializationOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureDateTimeSerializationOptions(Action<DateTimeSerializationOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._dateTimeOptionsBuilder ??= new DateTimeSerializationOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal IDateTimeSerializationOptions BuildDateTimeOptions()
+			=> new ImmutableDateTimeSerializationOptions(this._dateTimeOptionsBuilder ?? DateTimeSerializationOptionsBuilder.Default);
+
+		/// <summary>
+		///		Configures <see cref="DateTime"/> and similar types serialization behavior.
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="DictionarySerializationOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureDictionarySerializationOptions(Action<DictionarySerializationOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._dictionaryOptionsBuilder ??= new DictionarySerializationOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal IDictionarySerializationOptions BuildDictionaryOptions()
+			=> this._dictionaryOptionsBuilder == null ? ImmutableDictionarySerializationOptions.Default : new ImmutableDictionarySerializationOptions(this._dictionaryOptionsBuilder);
+
+		/// <summary>
+		///		Configures options for each serialization operations.
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="SerializationOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureSerializationOptions(Action<SerializationOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._serializationOptionsBuilder ??= new SerializationOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal SerializationOptions BuildSerializationOptions()
+			=> this._serializationOptionsBuilder == null ? SerializationOptions.Default : new SerializationOptions(this._serializationOptionsBuilder);
+
+		/// <summary>
+		///		Configures options for each deserialization operations.
+		/// </summary>
+		/// <param name="configure">A delegate which configure the options through passed <see cref="DeserializationOptionsBuilder"/>.</param>
+		/// <returns>This <see cref="SerializerGenerationOptionsBuilder"/> instance.</returns>
+		public SerializerGenerationOptionsBuilder ConfigureDeserializationOptions(Action<DeserializationOptionsBuilder> configure)
+		{
+			Ensure.NotNull(configure);
+			var builder = this._deserializationOptionsBuilder ??= new DeserializationOptionsBuilder();
+			configure(builder);
+			return this;
+		}
+
+		internal DeserializationOptions BuildDeserializationOptions()
+			=> this._deserializationOptionsBuilder == null ? DeserializationOptions.Default : new DeserializationOptions(this._deserializationOptionsBuilder);
+
+		internal ISerializerGenerationOptions Build() => new ImmutableSerializerGenerationOptions(this);
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerProvider.cs b/src/MsgPack.Serialization/Serialization/SerializerProvider.cs
new file mode 100644
index 000000000..413a041bb
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerProvider.cs
@@ -0,0 +1,405 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using MsgPack.Codecs;
+using MsgPack.Serialization.BuiltinSerializers;
+using MsgPack.Serialization.Polymorphic;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		A single entry point to get or create <see cref="Serializer"/> which is entry point of serialization.
+	/// </summary>
+	public sealed class SerializerProvider : IObjectSerializerProvider
+	{
+#warning TODO: Revise
+		private static SerializerProvider s_default = new SerializerProvider();
+
+		public static SerializerProvider Default
+		{
+			get => s_default;
+			set => s_default = Ensure.NotNull(value);
+		}
+
+		private readonly SerializerBuilderRegistry _builderRegistry;
+		private readonly ConcurrentDictionary<RuntimeTypeHandle, IObjectSerializerProvider> _innerProviders;
+		private readonly ConcurrentDictionary<RuntimeTypeHandle, Serializer> _serializers;
+
+		internal ISerializerGenerationOptions SerializerGenerationOptions { get; }
+
+		private ResolveObjectSerializerEventHandler? _resolveSerializer;
+
+		// Unity cannot use Interlocked.CompareExchange<T>, so use explicit implementation here.
+		/// <summary>
+		///		Occurs when the context have not find appropriate registered nor built-in serializer for specified type.
+		/// </summary>
+		/// <remarks>
+		///		This event will be occured when the context could not found known serializer from:
+		///		<list type="bullet">
+		///			<item>
+		///				Known built-in serializers for arrays, nullables, and collections, etc.
+		///			</item>
+		///			<item>
+		///				Known default serializers for some known various FCL value types and some reference types.
+		///			</item>
+		///			<item>
+		///				Previously registered or generated serializer.
+		///			</item>
+		///		</list>
+		///		You can instantiate your custom serializer using various <see cref="ResolveSerializerEventArgs" /> properties,
+		///		and then call <see cref="ResolveSerializerEventArgs.SetSerializer{T}"/> to provide toward the context.
+		///		<note>
+		///			You can use <see cref="SerializerProvider" /> to get dependent serializers as you like, 
+		///			but you should never explicitly register new serializer(s) explicitly via the context from the event handler and its dependents.
+		///			Instead, you specify the instanciated serializer with <see cref="ResolveSerializerEventArgs.SetSerializer{T}"/> once at a time. 
+		///			Dependent serializer(s) should be registered via next (nested) raise of this event.
+		///		</note>
+		///		<note>
+		///			The context implicitly holds 'lock' for the target type for the requested serializer in the current thread.
+		///			So you should not use any synchronization primitives in the event handler and its dependents,
+		///			or you may face complex dead lock.
+		///			That is, the event handler should be as simple as possible like just instanciate the serializer and set it to the event argument.
+		///		</note>
+		/// </remarks>
+		public event Func<ResolveObjectSerializerEventArgs, ObjectSerializer> ResolveObjectSerializer
+		{
+			add
+			{
+#if UNITY
+				lock(this._resolveSerializerSyncRoot)
+				{
+					this._resolveSerializer += value;
+				}
+#else
+
+				ResolveObjectSerializerEventHandler? expectedHandler;
+				var actualHandler = this._resolveSerializer;
+				do
+				{
+					expectedHandler = actualHandler;
+					var combined = (ResolveObjectSerializerEventHandler)Delegate.Combine(expectedHandler, value);
+					actualHandler = Interlocked.CompareExchange(ref this._resolveSerializer, combined, expectedHandler);
+				}
+				while (expectedHandler != actualHandler);
+#endif
+			}
+			remove
+			{
+#if UNITY
+				lock(this._resolveSerializerSyncRoot)
+				{
+					// ReSharper disable once DelegateSubtraction
+					this._resolveSerializer -= value;
+				}
+#else
+				ResolveObjectSerializerEventHandler? expectedHandler;
+				var actualHandler = this._resolveSerializer;
+				do
+				{
+					expectedHandler = actualHandler;
+					var removed = (ResolveObjectSerializerEventHandler?)Delegate.Remove(expectedHandler, value);
+					actualHandler = Interlocked.CompareExchange(ref this._resolveSerializer, removed, expectedHandler);
+				}
+				while (expectedHandler != actualHandler);
+#endif
+			}
+		}
+
+		private ObjectSerializer? OnResolveSerializer(Type targetType, PolymorphismSchema schema)
+		{
+#if UNITY
+			lock(this._resolveSerializerSyncRoot)
+			{
+			var handler = this._resolveSerializer;
+#else
+			var handler = Interlocked.CompareExchange(ref this._resolveSerializer, null, null);
+#endif
+			if (handler == null)
+			{
+				return null;
+			}
+
+			// Lazily allocate event args memory.
+			var e = new ResolveObjectSerializerEventArgs(this, targetType, schema);
+			handler(ref e);
+			return e.GetSerializer();
+#if UNITY
+			}
+#endif
+		}
+
+		public SerializerProvider()
+			: this(new SerializerGenerationOptionsBuilder()) { }
+
+		public SerializerProvider(
+			SerializerGenerationOptionsBuilder optionsBuilder
+		)
+			: this(Ensure.NotNull(optionsBuilder), SerializerBuilderRegistry.Instance) { }
+
+		internal SerializerProvider(
+			SerializerGenerationOptionsBuilder optionsBuilder,
+			SerializerBuilderRegistry builderRegistry
+		)
+		{
+			this._innerProviders = new ConcurrentDictionary<RuntimeTypeHandle, IObjectSerializerProvider>();
+			this._serializers = new ConcurrentDictionary<RuntimeTypeHandle, Serializer>();
+			this.SerializerGenerationOptions = optionsBuilder.Build();
+			this._builderRegistry = builderRegistry;
+		}
+
+		internal Type EnsureDateTimeLikeType(Type targetType)
+		{
+			Ensure.NotNull(targetType);
+			var knownDateTimeLikeTypes = this.SerializerGenerationOptions.DateTimeOptions.KnownDateTimeLikeTypes;
+
+			if (!knownDateTimeLikeTypes.Contains(targetType))
+			{
+				var nullableUnderlyingType = Nullable.GetUnderlyingType(targetType);
+				if (nullableUnderlyingType == null || !knownDateTimeLikeTypes.Contains(nullableUnderlyingType))
+				{
+					Throw.TargetTypeIsNotDateTimeLikeType(targetType, knownDateTimeLikeTypes);
+				}
+			}
+
+			return targetType;
+		}
+
+		public Serializer GetSerializer(Type targetType, object? providerParameter, CodecProvider codecProvider)
+		{
+			var context = (This: this, Type: targetType, CodecProvider: codecProvider, ProviderParameter: providerParameter);
+			return this._serializers.GetOrAdd(targetType.TypeHandle, (_, x) => x.This.CreateSerializer(x.Type, x.CodecProvider, x.ProviderParameter), context);
+		}
+
+		private Serializer CreateSerializer(Type targetType, CodecProvider codecProvider, object? providerParameter)
+			=> SerializerFactory.CreateSerializer(
+				targetType,
+				codecProvider,
+				this.GetObjectSerializer(targetType, providerParameter),
+				this.SerializerGenerationOptions.SerializationOptions,
+				this.SerializerGenerationOptions.DeserializationOptions
+			);
+
+		ObjectSerializer IObjectSerializerProvider.GetSerializer(Type targetType, object? providerParameter)
+			=> this.GetObjectSerializer(targetType, providerParameter);
+
+		private ObjectSerializer GetObjectSerializer(Type targetType, object? providerParameter)
+		{
+			var context = (This: this, Type: targetType, ProviderParameter: providerParameter);
+			return this._innerProviders.GetOrAdd(targetType.TypeHandle, (_, x) => x.This.CreateObjectSerializerProvider(x.Type, x.ProviderParameter), context).GetSerializer(targetType, providerParameter);
+		}
+
+		private readonly object _generationLock = new object();
+		private readonly Dictionary<Type, IObjectSerializerProvider> _typeLock = new Dictionary<Type, IObjectSerializerProvider>();
+
+		private IObjectSerializerProvider CreateObjectSerializerProvider(Type targetType, object? providerParameter)
+		{
+			// Explicitly registered serializer should always used, so get it first.
+			if (this._innerProviders.TryGetValue(targetType.TypeHandle, out var provider))
+			{
+				return provider;
+			}
+
+			lock (this._generationLock)
+			{
+				// Re-get to check because other thread might create the serializer when I wait the lock.
+				if (this._innerProviders.TryGetValue(targetType.TypeHandle, out provider))
+				{
+					return provider;
+				}
+
+				try
+				{
+					if (this._typeLock.TryGetValue(targetType, out var lazyProvider))
+					{
+						return lazyProvider;
+					}
+
+#warning TODO: Revise option
+					var isTuple = TupleItems.IsTuple(targetType);
+					var metadata =
+						isTuple ?
+							SerializationMetadataFactory.GetTupleMetadata(targetType) :
+							SerializationMetadataFactory.GetObjectMetadata(targetType, this.SerializerGenerationOptions);
+					var capabilities = metadata.GetCapabilities();
+
+					this._typeLock[targetType] =
+						new StaticObjectSerializerProvider(
+							SerializerFactory.CreateObjectSerializer(
+								typeof(LazyDelegatingObjectSerializer<>),
+								targetType,
+								this,
+								capabilities
+							)
+						);
+
+					return this.CreateRealObjectSerializerProvider(targetType, providerParameter, provider, metadata, isTuple);
+				}
+				finally
+				{
+					this._typeLock.Remove(targetType);
+				}
+			}
+		}
+
+		private IObjectSerializerProvider CreateRealObjectSerializerProvider(
+			Type targetType,
+			object? providerParameter,
+			IObjectSerializerProvider? provider,
+			in SerializationTarget metadata,
+			bool isTuple
+		)
+		{
+			var schema = (providerParameter ?? PolymorphismSchema.Create(targetType, null)) as PolymorphismSchema ?? PolymorphismSchema.Default;
+
+#warning TODO: GenericSerializer.Create<T> here! (Mainly, collections)
+			//serializer = GenericSerializer.Create<T>(this, schema);
+
+			var builder =
+				this.SerializerGenerationOptions.IsRuntimeCodeGenerationDisabled ?
+					this._builderRegistry.GetForReflection() :
+					this._builderRegistry.GetForRuntimeCodeGeneration();
+
+			var registrationOptions = SerializerRegistrationOptions.WithNullable;
+			var serializer = this.OnResolveSerializer(targetType, schema);
+			if (serializer == null)
+			{
+				var underlyingType = Nullable.GetUnderlyingType(targetType);
+				if (underlyingType != null)
+				{
+					provider = this.CreateObjectSerializerProvider(underlyingType, providerParameter);
+					registrationOptions &= ~SerializerRegistrationOptions.WithNullable;
+				}
+				else
+				{
+					if (targetType.GetIsEnum())
+					{
+						provider = new EnumSerializerProvider(targetType, this);
+					}
+					else if (this.SerializerGenerationOptions.DateTimeOptions.KnownDateTimeLikeTypes.Contains(targetType))
+					{
+						provider = this.CreateDateTimeSerializerProvider(targetType);
+					}
+					else if (isTuple)
+					{
+						serializer = builder.BuildTupleSerializer(targetType, this, metadata, this.SerializerGenerationOptions);
+					}
+					else
+					{
+						serializer = builder.BuildObjectSerializer(targetType, this, metadata, this.SerializerGenerationOptions);
+					}
+				}
+			}
+
+			provider = this.RegisterSerializerAndProvider(targetType, registrationOptions, provider, serializer);
+
+			return provider;
+		}
+
+		private IObjectSerializerProvider CreateDateTimeSerializerProvider(Type targetType)
+		{
+			if (targetType == typeof(DateTimeOffset))
+			{
+				return DateTimeSerializerProvider.CreateDateTimeOffset(this);
+			}
+			else if (targetType == typeof(DateTime))
+			{
+				return DateTimeSerializerProvider.CreateDateTime(this);
+			}
+			else if (targetType == typeof(Timestamp))
+			{
+				return DateTimeSerializerProvider.CreateTimestamp(this);
+			}
+			else
+			{
+				Throw.DateTimeSerializerProviderIsNotRegistered(targetType);
+				return default; // Never reaches
+			}
+		}
+
+		public void Register(Type targetType, ObjectSerializer serializer, SerializerRegistrationOptions registrationOptions)
+		{
+			Ensure.NotNull(targetType);
+			Ensure.NotNull(serializer);
+
+			lock (this._generationLock)
+			{
+				this.RegisterSerializerAndProvider(targetType, registrationOptions, provider: null, serializer);
+			}
+		}
+
+		public void RegisterDateTimeSerializerProvider(Type targetType, IObjectSerializerProvider provider, SerializerRegistrationOptions registrationOptions)
+		{
+			this.EnsureDateTimeLikeType(targetType);
+			Ensure.NotNull(provider);
+
+			lock (this._generationLock)
+			{
+				this.RegisterSerializerAndProvider(targetType, registrationOptions, provider, serializer: null);
+			}
+		}
+
+		private IObjectSerializerProvider RegisterSerializerAndProvider(
+			Type targetType,
+			SerializerRegistrationOptions registrationOptions,
+			IObjectSerializerProvider? provider,
+			ObjectSerializer? serializer
+		)
+		{
+			var overwrites = (registrationOptions & SerializerRegistrationOptions.AllowOverride) != 0;
+
+			if (provider == null)
+			{
+				Debug.Assert(serializer != null);
+
+				if (targetType.GetIsValueType())
+				{
+					provider = new StaticObjectSerializerProvider(serializer);
+
+					if ((registrationOptions & SerializerRegistrationOptions.WithNullable) != 0)
+					{
+						// Create nullable companion
+						var nullableType = typeof(Nullable<>).MakeGenericType(targetType);
+						var nullableProvider =
+							new StaticObjectSerializerProvider(
+								SerializerFactory.CreateNullableObjectSerializer(
+									nullableType,
+									targetType,
+									this,
+									serializer
+								)
+							);
+						if (overwrites)
+						{
+							this._innerProviders[nullableType.TypeHandle] = nullableProvider;
+						}
+						else
+						{
+							this._innerProviders.TryAdd(nullableType.TypeHandle, nullableProvider);
+						}
+					}
+				}
+				else
+				{
+					provider = new PolymorphicSerializerProvider(targetType, serializer!);
+				}
+			}
+
+			if (overwrites)
+			{
+				this._innerProviders[targetType.TypeHandle] = provider;
+			}
+			else
+			{
+				this._innerProviders.TryAdd(targetType.TypeHandle, provider);
+			}
+
+			return provider;
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.cs b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.cs
new file mode 100644
index 000000000..3e983974c
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.cs
@@ -0,0 +1,70 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	public partial class SerializerProviderExtensions
+	{
+		/// <summary>
+		///		Registers specified <see cref="ObjectSerializer{}" /> for the target type.
+		/// </summary>
+		/// <param name="provider">The <see cref="SerializerProvider" />.</param>
+		/// <param name="targetType">The type of the serialization target.</param>
+		/// <param name="serializer">The <see cref="ObjectSerializer" /> to be registered.</param>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="serializer" /> is <c>null</c>.
+		/// </exception>
+		public static void Register(this SerializerProvider provider, Type targetType, ObjectSerializer serializer)
+			=> Ensure.NotNull(provider).Register(targetType, serializer, SerializerRegistrationOptions.None);
+
+		/// <summary>
+		///		Registers specified <see cref="ObjectSerializer{}" /> for the target type with overriding existing registration.
+		/// </summary>
+		/// <param name="provider">The <see cref="SerializerProvider" />.</param>
+		/// <param name="targetType">The type of the serialization target.</param>
+		/// <param name="serializer">The <see cref="ObjectSerializer" /> to be registered.</param>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="serializer" /> is <c>null</c>.
+		/// </exception>
+		public static void RegisterOverride(this SerializerProvider provider, Type targetType, ObjectSerializer serializer)
+			=> Ensure.NotNull(provider).Register(targetType, serializer, SerializerRegistrationOptions.AllowOverride);
+
+		/// <summary>
+		///		Registers specified <see cref="ObjectSerializer{{T}}" /> for the target type.
+		/// </summary>
+		/// <typeparam name="T">The type of the serialization target.</typeparam>
+		/// <param name="provider">The <see cref="SerializerProvider" />.</param>
+		/// <param name="serializer">The <see cref="ObjectSerializer{T}" /> to be registered.</param>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="serializer" /> is <c>null</c>.
+		/// </exception>
+		public static void Register<T>(this SerializerProvider provider, ObjectSerializer<T> serializer)
+			=> Ensure.NotNull(provider).Register(typeof(T), serializer, SerializerRegistrationOptions.None);
+
+		/// <summary>
+		///		Registers specified <see cref="ObjectSerializer{{T}}" /> for the target type with overriding existing registration.
+		/// </summary>
+		/// <typeparam name="T">The type of the serialization target.</typeparam>
+		/// <param name="provider">The <see cref="SerializerProvider" />.</param>
+		/// <param name="serializer">The <see cref="ObjectSerializer{T}" /> to be registered.</param>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="serializer" /> is <c>null</c>.
+		/// </exception>
+		public static void RegisterOverride<T>(this SerializerProvider provider, ObjectSerializer<T> serializer)
+			=> Ensure.NotNull(provider).Register(typeof(T), serializer, SerializerRegistrationOptions.AllowOverride);
+
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.tt b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.tt
new file mode 100644
index 000000000..a4b01fe03
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.Register.tt
@@ -0,0 +1,81 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ import namespace="System.Globalization" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ output extension=".cs" #>
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	public partial class SerializerProviderExtensions
+	{
+<#
+var specs =
+	new []
+	{
+		new { MethodSuffix = String.Empty,	Options = "SerializerRegistrationOptions.None",				Summary = "Registers specified <see cref=\"ObjectSerializer{{{0}}}\" /> for the target type." },
+		new { MethodSuffix = "Override",	Options = "SerializerRegistrationOptions.AllowOverride",	Summary = "Registers specified <see cref=\"ObjectSerializer{{{0}}}\" /> for the target type with overriding existing registration." },
+	};
+
+foreach (var isGeneric in new [] { false, true })
+{
+	var genericTypeParameter = isGeneric ? "<T>" : String.Empty;
+	var docGenericTypeParameter = isGeneric ? "{T}" : String.Empty;
+	var typeParameter = isGeneric ? String.Empty : "Type targetType, ";
+	var typeArgument = isGeneric ? "typeof(T)" : "targetType";
+
+	foreach (var spec in specs)
+	{
+#>
+		/// <summary>
+		///		<#= String.Format(CultureInfo.InvariantCulture, spec.Summary, docGenericTypeParameter) #>
+		/// </summary>
+<#
+	if (isGeneric)
+	{
+#>
+		/// <typeparam name="T">The type of the serialization target.</typeparam>
+<#
+	}
+#>
+		/// <param name="provider">The <see cref="SerializerProvider" />.</param>
+<#
+	if (!isGeneric)
+	{
+#>
+		/// <param name="targetType">The type of the serialization target.</param>
+<#
+	}
+#>
+		/// <param name="serializer">The <see cref="ObjectSerializer<#= docGenericTypeParameter #>" /> to be registered.</param>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+<#
+	if (!isGeneric)
+	{
+#>
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+<#
+	}
+#>
+		///		Or, <paramref name="serializer" /> is <c>null</c>.
+		/// </exception>
+		public static void Register<#= spec.MethodSuffix #><#= genericTypeParameter #>(this SerializerProvider provider, <#= typeParameter #>ObjectSerializer<#= genericTypeParameter #> serializer)
+			=> Ensure.NotNull(provider).Register(<#= typeArgument #>, serializer, <#= spec.Options #>);
+
+<#
+	}
+}
+#>
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.cs b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.cs
new file mode 100644
index 000000000..d0cecc2c6
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.cs
@@ -0,0 +1,397 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+#nullable enable
+
+// <auto-generated /> 
+// This file is generated from acompanying .tt file.
+// DO NOT edit this file directly, edit .tt file instead.
+
+using System;
+using System.Runtime.CompilerServices;
+using MsgPack.Codecs;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines extension methods with typed parameter for serializer providers.
+	/// </summary>
+	public static partial class SerializerProviderExtensions
+	{
+		/// <summary>
+		///		Gets the <see cref="ObjectSerializer"/> object for the specified type without any polymorphism.
+		/// </summary>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type cannot be abstract type including interfaces.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <returns>The <see cref="ObjectSerializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="targetType"> is abstract type and is not known collection interface.
+		/// </exception>
+		public static ObjectSerializer GetSerializer(this IObjectSerializerProvider provider, Type targetType)
+			=> (Ensure.NotNull(provider).GetSerializer(targetType, null) as ObjectSerializer)!;
+
+		/// <summary>
+		///		Gets the polymorphic <see cref="ObjectSerializer"/> object for the specified type, and polymorphism schema defined by the member metadata.
+		/// </summary>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type can be abstract type including interfaces.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="schema">The <see cref="PolymorphismSchema"/> to tell polymoprhism related information to the underlying serializer provider. This value is defined by the member metadata.. This parameer is optional.</param>
+		/// <returns>The <see cref="ObjectSerializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <remarks>
+		///		When <paramref name="schema"/> is <c>null</c>, this method is identical to <see cref="GetSerializer{T}(IObjectSerializerProvider)"/>.
+		/// </remarks>
+		public static ObjectSerializer GetPolymorphicSerializer(this IObjectSerializerProvider provider, Type targetType, PolymorphismSchema? schema = null)
+			=> (Ensure.NotNull(provider).GetSerializer(targetType, schema ?? PolymorphismSchema.Default) as ObjectSerializer)!;
+
+		/// <summary>
+		///		Gets the <see cref="ObjectSerializer"/> object for the specified enum type, and enum serialization method defined by the member metadata.
+		/// </summary>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type must be enum type.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultEnumSerializationMethod">The <see cref="EnumSerializationMethod"/> to tell enum serialization method to the underlying serializer provider. This value is defined by the member metadata. This parameer is optional.</param>
+		/// <returns>The <see cref="ObjectSerializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="targetType"> is not enum type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultEnumSerializationMethod"/> is <c>null</c>, the default value which was configured in <see cref="EnumSerializationOptionsBuilder"/> or the underlying codec is used.
+		/// </remarks>
+		public static ObjectSerializer GetEnumSerializer(this IObjectSerializerProvider provider, Type targetType, EnumSerializationMethod? defaultEnumSerializationMethod = null)
+				=> (Ensure.NotNull(provider).GetSerializer(EnsureEnumType(targetType), BoxedEnumSerializationMethod.Get(defaultEnumSerializationMethod)) as ObjectSerializer)!;
+
+		/// <summary>
+		///		Gets the <see cref="ObjectSerializer"/> object for the specified date time like type, and date time conversion method defined by the member metadata.
+		/// </summary>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type should be one of the well known date time like types.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultDateTimeConversionMethod">The <see cref="DateTimeConversionMethod"/> to tell date time conversion method to the underlying serializer provider. This value is defined by the member metadata. This parameter is optional.</param>
+		/// <returns>The <see cref="ObjectSerializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="targetType"> is not a well known date time like type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultDateTimeConversionMethod"/> is <c>null</c>, the default value which was configured in <see cref="DateTimeSerializationOptionsBuilder"/> or the underlying codec is used.
+		///		The following types are considered as date time like types and their <see cref="Nullable{T}"/>:
+		///		<list type="bullet">
+		///			<item><see cref="DateTime"/></item>
+		///			<item><see cref="DateTimeOffset"/></item>
+		///			<item><see cref="Timestamp"/></item>
+		///		</list>
+		/// </remarks>
+		public static ObjectSerializer GetDateTimeSerializer(this IObjectSerializerProvider provider, Type targetType, DateTimeConversionMethod? defaultDateTimeConversionMethod = null)
+			=> (Ensure.NotNull(provider).GetSerializer(provider.EnsureDateTimeLikeType(targetType), BoxedDateTimeConversionMethod.Get(defaultDateTimeConversionMethod)) as ObjectSerializer)!;
+
+		/// <summary>
+		///		Gets the <see cref="ObjectSerializer{T}"/> object for the specified type without any polymorphism.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type cannot be abstract type including interfaces.</typeparam>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <returns>The <see cref="ObjectSerializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="InvalidOperationException">
+		///		<typeparamref name="T"> is abstract type and is not known collection interface.
+		/// </exception>
+		public static ObjectSerializer<T> GetSerializer<T>(this IObjectSerializerProvider provider)
+			=> (Ensure.NotNull(provider).GetSerializer(typeof(T), null) as ObjectSerializer<T>)!;
+
+		/// <summary>
+		///		Gets the polymorphic <see cref="ObjectSerializer{T}"/> object for the specified type, and polymorphism schema defined by the member metadata.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type can be abstract type including interfaces.</typeparam>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="schema">The <see cref="PolymorphismSchema"/> to tell polymoprhism related information to the underlying serializer provider. This value is defined by the member metadata.. This parameer is optional.</param>
+		/// <returns>The <see cref="ObjectSerializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <remarks>
+		///		When <paramref name="schema"/> is <c>null</c>, this method is identical to <see cref="GetSerializer{T}(IObjectSerializerProvider)"/>.
+		/// </remarks>
+		public static ObjectSerializer<T> GetPolymorphicSerializer<T>(this IObjectSerializerProvider provider, PolymorphismSchema? schema = null)
+			=> (Ensure.NotNull(provider).GetSerializer(typeof(T), schema ?? PolymorphismSchema.Default) as ObjectSerializer<T>)!;
+
+		/// <summary>
+		///		Gets the <see cref="ObjectSerializer{T}"/> object for the specified enum type, and enum serialization method defined by the member metadata.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type must be enum type.</typeparam>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultEnumSerializationMethod">The <see cref="EnumSerializationMethod"/> to tell enum serialization method to the underlying serializer provider. This value is defined by the member metadata. This parameer is optional.</param>
+		/// <returns>The <see cref="ObjectSerializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="InvalidOperationException">
+		///		<typeparamref name="T"> is not enum type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultEnumSerializationMethod"/> is <c>null</c>, the default value which was configured in <see cref="EnumSerializationOptionsBuilder"/> or the underlying codec is used.
+		/// </remarks>
+		public static ObjectSerializer<T> GetEnumSerializer<T>(this IObjectSerializerProvider provider, EnumSerializationMethod? defaultEnumSerializationMethod = null)
+				where T : Enum
+				=> (Ensure.NotNull(provider).GetSerializer(EnsureEnumType<T>(), BoxedEnumSerializationMethod.Get(defaultEnumSerializationMethod)) as ObjectSerializer<T>)!;
+
+		/// <summary>
+		///		Gets the <see cref="ObjectSerializer{T}"/> object for the specified date time like type, and date time conversion method defined by the member metadata.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type should be one of the well known date time like types.</typeparam>
+		/// <param name="provider">The <see cref="IObjectSerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultDateTimeConversionMethod">The <see cref="DateTimeConversionMethod"/> to tell date time conversion method to the underlying serializer provider. This value is defined by the member metadata. This parameter is optional.</param>
+		/// <returns>The <see cref="ObjectSerializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="InvalidOperationException">
+		///		<typeparamref name="T"> is not a well known date time like type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultDateTimeConversionMethod"/> is <c>null</c>, the default value which was configured in <see cref="DateTimeSerializationOptionsBuilder"/> or the underlying codec is used.
+		///		The following types are considered as date time like types and their <see cref="Nullable{T}"/>:
+		///		<list type="bullet">
+		///			<item><see cref="DateTime"/></item>
+		///			<item><see cref="DateTimeOffset"/></item>
+		///			<item><see cref="Timestamp"/></item>
+		///		</list>
+		/// </remarks>
+		public static ObjectSerializer<T> GetDateTimeSerializer<T>(this IObjectSerializerProvider provider, DateTimeConversionMethod? defaultDateTimeConversionMethod = null)
+			=> (Ensure.NotNull(provider).GetSerializer(provider.EnsureDateTimeLikeType(typeof(T)), BoxedDateTimeConversionMethod.Get(defaultDateTimeConversionMethod)) as ObjectSerializer<T>)!;
+
+		/// <summary>
+		///		Gets the <see cref="Serializer"/> object for the specified type without any polymorphism.
+		/// </summary>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type cannot be abstract type including interfaces.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <returns>The <see cref="Serializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="targetType"> is abstract type and is not known collection interface.
+		/// </exception>
+		public static Serializer GetSerializer(this SerializerProvider provider, Type targetType, CodecProvider codecProvider)
+			=> (Ensure.NotNull(provider).GetSerializer(targetType, null, Ensure.NotNull(codecProvider)) as Serializer)!;
+
+		/// <summary>
+		///		Gets the polymorphic <see cref="Serializer"/> object for the specified type, and polymorphism schema defined by the member metadata.
+		/// </summary>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type can be abstract type including interfaces.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="schema">The <see cref="PolymorphismSchema"/> to tell polymoprhism related information to the underlying serializer provider. This value is defined by the member metadata.. This parameer is optional.</param>
+		/// <returns>The <see cref="Serializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <remarks>
+		///		When <paramref name="schema"/> is <c>null</c>, this method is identical to <see cref="GetSerializer{T}(SerializerProvider)"/>.
+		/// </remarks>
+		public static Serializer GetPolymorphicSerializer(this SerializerProvider provider, Type targetType, CodecProvider codecProvider, PolymorphismSchema? schema = null)
+			=> (Ensure.NotNull(provider).GetSerializer(targetType, schema ?? PolymorphismSchema.Default, Ensure.NotNull(codecProvider)) as Serializer)!;
+
+		/// <summary>
+		///		Gets the <see cref="Serializer"/> object for the specified enum type, and enum serialization method defined by the member metadata.
+		/// </summary>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type must be enum type.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultEnumSerializationMethod">The <see cref="EnumSerializationMethod"/> to tell enum serialization method to the underlying serializer provider. This value is defined by the member metadata. This parameer is optional.</param>
+		/// <returns>The <see cref="Serializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="targetType"> is not enum type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultEnumSerializationMethod"/> is <c>null</c>, the default value which was configured in <see cref="EnumSerializationOptionsBuilder"/> or the underlying codec is used.
+		/// </remarks>
+		public static Serializer GetEnumSerializer(this SerializerProvider provider, Type targetType, CodecProvider codecProvider, EnumSerializationMethod? defaultEnumSerializationMethod = null)
+				=> (Ensure.NotNull(provider).GetSerializer(EnsureEnumType(targetType), BoxedEnumSerializationMethod.Get(defaultEnumSerializationMethod), Ensure.NotNull(codecProvider)) as Serializer)!;
+
+		/// <summary>
+		///		Gets the <see cref="Serializer"/> object for the specified date time like type, and date time conversion method defined by the member metadata.
+		/// </summary>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="targetType">The target type of the serializer. This type should be one of the well known date time like types.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultDateTimeConversionMethod">The <see cref="DateTimeConversionMethod"/> to tell date time conversion method to the underlying serializer provider. This value is defined by the member metadata. This parameter is optional.</param>
+		/// <returns>The <see cref="Serializer"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="targetType" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="ArgumentException">
+		///		<paramref name="targetType"> is not a well known date time like type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultDateTimeConversionMethod"/> is <c>null</c>, the default value which was configured in <see cref="DateTimeSerializationOptionsBuilder"/> or the underlying codec is used.
+		///		The following types are considered as date time like types and their <see cref="Nullable{T}"/>:
+		///		<list type="bullet">
+		///			<item><see cref="DateTime"/></item>
+		///			<item><see cref="DateTimeOffset"/></item>
+		///			<item><see cref="Timestamp"/></item>
+		///		</list>
+		/// </remarks>
+		public static Serializer GetDateTimeSerializer(this SerializerProvider provider, Type targetType, CodecProvider codecProvider, DateTimeConversionMethod? defaultDateTimeConversionMethod = null)
+			=> (Ensure.NotNull(provider).GetSerializer(provider.EnsureDateTimeLikeType(targetType), BoxedDateTimeConversionMethod.Get(defaultDateTimeConversionMethod), Ensure.NotNull(codecProvider)) as Serializer)!;
+
+		/// <summary>
+		///		Gets the <see cref="Serializer{T}"/> object for the specified type without any polymorphism.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type cannot be abstract type including interfaces.</typeparam>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <returns>The <see cref="Serializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="InvalidOperationException">
+		///		<typeparamref name="T"> is abstract type and is not known collection interface.
+		/// </exception>
+		public static Serializer<T> GetSerializer<T>(this SerializerProvider provider, CodecProvider codecProvider)
+			=> (Ensure.NotNull(provider).GetSerializer(typeof(T), null, Ensure.NotNull(codecProvider)) as Serializer<T>)!;
+
+		/// <summary>
+		///		Gets the polymorphic <see cref="Serializer{T}"/> object for the specified type, and polymorphism schema defined by the member metadata.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type can be abstract type including interfaces.</typeparam>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="schema">The <see cref="PolymorphismSchema"/> to tell polymoprhism related information to the underlying serializer provider. This value is defined by the member metadata.. This parameer is optional.</param>
+		/// <returns>The <see cref="Serializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <remarks>
+		///		When <paramref name="schema"/> is <c>null</c>, this method is identical to <see cref="GetSerializer{T}(SerializerProvider)"/>.
+		/// </remarks>
+		public static Serializer<T> GetPolymorphicSerializer<T>(this SerializerProvider provider, CodecProvider codecProvider, PolymorphismSchema? schema = null)
+			=> (Ensure.NotNull(provider).GetSerializer(typeof(T), schema ?? PolymorphismSchema.Default, Ensure.NotNull(codecProvider)) as Serializer<T>)!;
+
+		/// <summary>
+		///		Gets the <see cref="Serializer{T}"/> object for the specified enum type, and enum serialization method defined by the member metadata.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type must be enum type.</typeparam>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultEnumSerializationMethod">The <see cref="EnumSerializationMethod"/> to tell enum serialization method to the underlying serializer provider. This value is defined by the member metadata. This parameer is optional.</param>
+		/// <returns>The <see cref="Serializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="InvalidOperationException">
+		///		<typeparamref name="T"> is not enum type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultEnumSerializationMethod"/> is <c>null</c>, the default value which was configured in <see cref="EnumSerializationOptionsBuilder"/> or the underlying codec is used.
+		/// </remarks>
+		public static Serializer<T> GetEnumSerializer<T>(this SerializerProvider provider, CodecProvider codecProvider, EnumSerializationMethod? defaultEnumSerializationMethod = null)
+				where T : Enum
+				=> (Ensure.NotNull(provider).GetSerializer(EnsureEnumType<T>(), BoxedEnumSerializationMethod.Get(defaultEnumSerializationMethod), Ensure.NotNull(codecProvider)) as Serializer<T>)!;
+
+		/// <summary>
+		///		Gets the <see cref="Serializer{T}"/> object for the specified date time like type, and date time conversion method defined by the member metadata.
+		/// </summary>
+		/// <typeparam name="T">The target type of the serializer. This type should be one of the well known date time like types.</typeparam>
+		/// <param name="provider">The <see cref="SerializerProvider"/>.</param>
+		/// <param name="codecProvider">The <see cref="CodecProvider" /> to get <see cref="FormatEncoder" /> and <see cref="FormatDecoder" />.</param>
+		/// <param name="defaultDateTimeConversionMethod">The <see cref="DateTimeConversionMethod"/> to tell date time conversion method to the underlying serializer provider. This value is defined by the member metadata. This parameter is optional.</param>
+		/// <returns>The <see cref="Serializer{T}"/> object for the specified type.</returns>
+		/// <exception cref="ArgumentNullException">
+		///		<paramref name="provider" /> is <c>null</c>.
+		///		Or, <paramref name="codecProvider" /> is <c>null</c>.
+		///	</exception>
+		/// <exception cref="InvalidOperationException">
+		///		<typeparamref name="T"> is not a well known date time like type.
+		/// </exception>
+		/// <remarks>
+		///		When <paramref name="defaultDateTimeConversionMethod"/> is <c>null</c>, the default value which was configured in <see cref="DateTimeSerializationOptionsBuilder"/> or the underlying codec is used.
+		///		The following types are considered as date time like types and their <see cref="Nullable{T}"/>:
+		///		<list type="bullet">
+		///			<item><see cref="DateTime"/></item>
+		///			<item><see cref="DateTimeOffset"/></item>
+		///			<item><see cref="Timestamp"/></item>
+		///		</list>
+		/// </remarks>
+		public static Serializer<T> GetDateTimeSerializer<T>(this SerializerProvider provider, CodecProvider codecProvider, DateTimeConversionMethod? defaultDateTimeConversionMethod = null)
+			=> (Ensure.NotNull(provider).GetSerializer(provider.EnsureDateTimeLikeType(typeof(T)), BoxedDateTimeConversionMethod.Get(defaultDateTimeConversionMethod), Ensure.NotNull(codecProvider)) as Serializer<T>)!;
+
+		private static Type EnsureEnumType(Type targetType, [CallerArgumentExpression("targetType")] string? paramName = null)
+		{
+			if (!Ensure.NotNull(targetType).GetIsEnum())
+			{
+				ThrowIsNotEnumType(targetType, paramName);
+			}
+
+			return targetType;
+		}
+
+		private static Type EnsureEnumType<T>()
+		{
+			if (!typeof(T).GetIsEnum())
+			{
+				ThrowIsNotEnumType(typeof(T), null);
+			}
+
+			return typeof(T);
+		}
+
+		private static void ThrowIsNotEnumType(Type targetType, string? paramName)
+		{
+			var message = $"Type '{targetType}' is not enum type.";
+			if (paramName == null)
+			{
+				throw new InvalidOperationException(message);
+			}
+			else
+			{
+				throw new ArgumentException(message, paramName);
+			}
+		}
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.tt b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.tt
new file mode 100644
index 000000000..d8ff180d8
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/SerializerProviderExtensions.tt
@@ -0,0 +1,29 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ include file="../../Common/SerializerProviderExtensions.ttinclude" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+Write(
+	"MsgPack.Serialization",
+	"SerializerProviderExtensions",
+	WriteXmlDoc,
+	new [] { "MsgPack.Codecs" },
+	new Spec { BaseTypeName = "ObjectSerializer",	IsGeneric = false,	ProviderTypeName = "IObjectSerializerProvider",	IsObjectSerializer = true },
+	new Spec { BaseTypeName = "ObjectSerializer",	IsGeneric = true,	ProviderTypeName = "IObjectSerializerProvider",	IsObjectSerializer = true },
+	new Spec { BaseTypeName = "Serializer",			IsGeneric = false,	ProviderTypeName = "SerializerProvider"},
+	new Spec { BaseTypeName = "Serializer",			IsGeneric = true,	ProviderTypeName = "SerializerProvider"}
+);
+#>
+<#+
+private void WriteXmlDoc()
+{
+#>
+	/// <summary>
+	///		Defines extension methods with typed parameter for serializer providers.
+	/// </summary>
+<#+
+}
+#>
diff --git a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs b/src/MsgPack.Serialization/Serialization/Serializer`1.cs
similarity index 74%
rename from src/MsgPack.Abstraction/Serialization/Serializer`2.cs
rename to src/MsgPack.Serialization/Serialization/Serializer`1.cs
index a33e61069..47c130af6 100644
--- a/src/MsgPack.Abstraction/Serialization/Serializer`2.cs
+++ b/src/MsgPack.Serialization/Serialization/Serializer`1.cs
@@ -8,44 +8,43 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
-using MsgPack.Internal;
+using MsgPack.Codecs;
 
 namespace MsgPack.Serialization
 {
 	public abstract class Serializer<T> : Serializer
 	{
-		private readonly Func<FormatEncoder> _encoderFactory;
-		private readonly Func<FormatDecoder> _decoderFactory;
+		private readonly CodecProvider _codecProvider;
 		private readonly ObjectSerializer<T> _underlying;
 		private readonly SerializationOptions _serializationOptions;
 		private readonly DeserializationOptions _deserializationOptions;
 
+		public sealed override SerializerCapabilities Capabilities => this._underlying.Capabilities;
+
 		protected Serializer(
-			Func<FormatEncoder> encoderFactory,
-			Func<FormatDecoder> decoderFactory,
+			CodecProvider codecProvider,
 			ObjectSerializer<T> underlying,
 			SerializationOptions serializationOptions,
 			DeserializationOptions deserializationOptions
 		)
 		{
-			this._encoderFactory = Ensure.NotNull(encoderFactory);
-			this._decoderFactory = Ensure.NotNull(decoderFactory);
+			this._codecProvider = Ensure.NotNull(codecProvider);
 			this._underlying = Ensure.NotNull(underlying);
 			this._serializationOptions = Ensure.NotNull(serializationOptions);
 			this._deserializationOptions = Ensure.NotNull(deserializationOptions);
 		}
 
 		private void InitializeSerializationOperationContext(CancellationToken cancellationToken, out SerializationOperationContext context)
-			=> context = new SerializationOperationContext(this._encoderFactory(), this._serializationOptions, cancellationToken);
+			=> context = new SerializationOperationContext(this._codecProvider.GetEncoder(), this._serializationOptions, cancellationToken);
 
 		private void InitializeAsyncSerializationOperationContext(CancellationToken cancellationToken, out AsyncSerializationOperationContext context)
-			=> context = new AsyncSerializationOperationContext(this._encoderFactory(), this._serializationOptions, cancellationToken);
+			=> context = new AsyncSerializationOperationContext(this._codecProvider.GetEncoder(), this._serializationOptions, cancellationToken);
 
 		private void InitializeDeserializationOperationContext(CancellationToken cancellationToken, out DeserializationOperationContext context)
-			=> context = new DeserializationOperationContext(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+			=> context = new DeserializationOperationContext(this._codecProvider.GetDecoder(), this._deserializationOptions, cancellationToken);
 
 		private void InitializeAsyncDeserializationOperationContext(CancellationToken cancellationToken, out AsyncDeserializationOperationContext context)
-			=> context = new AsyncDeserializationOperationContext(this._decoderFactory(), this._deserializationOptions, cancellationToken);
+			=> context = new AsyncDeserializationOperationContext(this._codecProvider.GetDecoder(), this._deserializationOptions, cancellationToken);
 
 		/// <inheritdoc />
 		public sealed override void SerializeObject(object? obj, IBufferWriter<byte> sink, CancellationToken cancellationToken = default)
@@ -90,6 +89,7 @@ public T Deserialize(ref SequenceReader<byte> reader, CancellationToken cancella
 			return this._underlying.Deserialize(ref context, ref reader);
 		}
 
+		/// <inheritdoc />
 		public sealed override object? DeserializeObject(ref ReadOnlySequence<byte> source, CancellationToken cancellationToken = default)
 			=> this.Deserialize(ref source, cancellationToken);
 
@@ -127,34 +127,50 @@ public ValueTask<T> DeserializeAsync(Stream streamSource, CancellationToken canc
 			return this._underlying.DeserializeAsync(context, context.CreateSequence(streamSource));
 		}
 
-		public bool DeserializeTo(ref SequenceReader<byte> reader, T obj, CancellationToken cancellationToken = default)
+		/// <inheritdoc />
+		public sealed override bool DeserializeToObject(ref SequenceReader<byte> reader, object destination, CancellationToken cancellationToken = default)
+			=> this.DeserializeTo(ref reader, (T)destination, cancellationToken);
+
+		public bool DeserializeTo(ref SequenceReader<byte> reader, T destination, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.DeserializeTo(ref context, ref reader, obj);
+			return this._underlying.DeserializeTo(ref context, ref reader, destination);
 		}
 
-		public bool DeserializeTo(ref ReadOnlySequence<byte> source, T obj, CancellationToken cancellationToken = default)
+		/// <inheritdoc />
+		public sealed override bool DeserializeToObject(ref ReadOnlySequence<byte> source, object destination, CancellationToken cancellationToken = default)
+			=> this.DeserializeTo(ref source, (T)destination, cancellationToken);
+
+		public bool DeserializeTo(ref ReadOnlySequence<byte> source, T destination, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
 			var reader = new SequenceReader<byte>(source);
-			var result = this._underlying.DeserializeTo(ref context, ref reader, obj);
+			var result = this._underlying.DeserializeTo(ref context, ref reader, destination);
 			source = source.Slice(source.Start, reader.Position);
 			return result;
 		}
 
-		public bool DeserializeTo(ref ReadOnlyMemory<byte> memorySource, T obj, CancellationToken cancellationToken = default)
+		/// <inheritdoc />
+		public sealed override bool DeserializeToObject(ref ReadOnlyMemory<byte> memorySource, object destination, CancellationToken cancellationToken = default)
+			=> this.DeserializeTo(ref memorySource, (T)destination, cancellationToken);
+
+		public bool DeserializeTo(ref ReadOnlyMemory<byte> memorySource, T destination, CancellationToken cancellationToken = default)
 		{
 			this.InitializeDeserializationOperationContext(cancellationToken, out var context);
 			var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(memorySource));
-			var result = this._underlying.DeserializeTo(ref context, ref reader, obj);
+			var result = this._underlying.DeserializeTo(ref context, ref reader, destination);
 			memorySource = memorySource.Slice((int)reader.Consumed);
 			return result;
 		}
 
-		public ValueTask<bool> DeserializeToAsync(Stream streamSource, T obj, CancellationToken cancellationToken = default)
+		/// <inheritdoc />
+		public sealed override ValueTask<bool> DeserializeToObjectAsync(Stream streamSource, object destination, CancellationToken cancellationToken = default)
+			=> this.DeserializeToAsync(streamSource, (T)destination, cancellationToken);
+
+		public ValueTask<bool> DeserializeToAsync(Stream streamSource, T destination, CancellationToken cancellationToken = default)
 		{
 			this.InitializeAsyncDeserializationOperationContext(cancellationToken, out var context);
-			return this._underlying.DeserializeToAsync(context, context.CreateSequence(streamSource), obj);
+			return this._underlying.DeserializeToAsync(context, context.CreateSequence(streamSource), destination);
 		}
 	}
 }
diff --git a/src/MsgPack.Serialization/Serialization/StaticObjectSerializerProvider.cs b/src/MsgPack.Serialization/Serialization/StaticObjectSerializerProvider.cs
new file mode 100644
index 000000000..ccff7ecf1
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/StaticObjectSerializerProvider.cs
@@ -0,0 +1,24 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Simple, static provider of <see cref="ObjectSerializer"/>.
+	/// </summary>
+	internal sealed class StaticObjectSerializerProvider : IObjectSerializerProvider
+	{
+		private readonly ObjectSerializer _serializer;
+
+		public StaticObjectSerializerProvider(ObjectSerializer serialzier)
+		{
+			this._serializer = serialzier;
+		}
+
+		public ObjectSerializer GetSerializer(Type targetType, object? providerParameter)
+			=> this._serializer;
+	}
+}
diff --git a/src/MsgPack.Serialization/Serialization/Throw.Internal.cs b/src/MsgPack.Serialization/Serialization/Throw.Internal.cs
index c622df9dd..e4fc5f486 100644
--- a/src/MsgPack.Serialization/Serialization/Throw.Internal.cs
+++ b/src/MsgPack.Serialization/Serialization/Throw.Internal.cs
@@ -3,16 +3,26 @@
 // See the LICENSE in the project root for more information.
 
 using System;
+using System.Buffers;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Globalization;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
+using System.Text;
+using MsgPack.Internal;
 
 namespace MsgPack.Serialization
 {
 	internal partial class Throw
 	{
+		public static void CannotBeNull(Type type)
+		 => throw new SerializationException($"Value of type '{type}' cannot be null.");
+
+		public static void UnavailableMethod(string name, SerializationMethod method)
+			=> throw new NotSupportedException($"SerializationMethod '{method}' is not supported in '{name}' format.");
+
 		public static void NotSupportedBecauseCannotInstanciateAbstractType(Type type)
 			=> throw new NotSupportedException($"This operation is not supported because '{type}' cannot be instanciated.");
 
@@ -25,18 +35,97 @@ public static void DuplicatedAttributes(Dictionary<string, List<MemberInfo>> dup
 		public static void MemberIdIsDuplicated(int id, Type targetType)
 			=> throw new SerializationException($"The member ID '{id}' is duplicated in the '{targetType}' elementType.");
 
+		public static void DuplicatedOriginalName(string name)
+			=> throw new SerializationException($"A mapping for original member name '{name}' is duplicated.");
+
+		public static void IsNotEnum(Type type, string paramName)
+			=> throw new ArgumentException($"Type '{type}' is not enum.", paramName);
+
+		public static void UndefinedEnumName(string name, Type enumType, long position)
+			=> throw new SerializationException($"Name '{name}' is not considered as valid member of enum type '{enumType}' at position {position:#,0}.");
+
+		public static void UndefinedEnumMember<T>(T value, [CallerArgumentExpression("value")] string paramName = null!)
+			where T : Enum
+			=> throw new ArgumentOutOfRangeException(paramName, $"Value {value:D}(0x{value:X}) is not valid enum value of '{typeof(T)}' type.");
+
+		public static char? InvalidIso8601DecimalMark(char? value, [CallerArgumentExpression("value")] string paramName = null!)
+			=> throw new ArgumentOutOfRangeException(paramName, $"Value '{StringEscape.ForDisplay(value.GetValueOrDefault().ToString())}' is not valid ISO 8601 decimal separator.");
+
+		public static void UnsupportedEnumUnderlyingType(Type underlyingType)
+			=> throw new InvalidOperationException($"Type '{underlyingType}' cannot be underlying type of enum.");
+
+		public static void IncompatibleEnumUnderlyingValue(Type sourceType, Type targetEnumType, Type targetUnderlyingValue)
+			=> throw new SerializationException($"Cannot convert decoded '{sourceType}' type value to '{targetEnumType}' enum value. Decoded value type is not compatible with underlying type '{targetUnderlyingValue}'.");
+
+		public static void OutOfRangeEnumUnderlyingValue(Type sourceType, Type targetEnumType, Type targetUnderlyingValue, long value)
+			=> throw new SerializationException($"Cannot convert decoded '{sourceType}' type value to '{targetEnumType}' enum value. Decoded value '{value:#,0}' is not in range of valid underlying type '{targetUnderlyingValue}'.");
+
+		public static void OutOfRangeEnumUnderlyingValue(Type sourceType, Type targetEnumType, Type targetUnderlyingValue, ulong value)
+			=> throw new SerializationException($"Cannot convert decoded '{sourceType}' type value to '{targetEnumType}' enum value. Decoded value '{value:#,0}' is not in range of valid underlying type '{targetUnderlyingValue}'.");
+
+		public static void OutOfRangeEnumUnderlyingValue(Type sourceType, Type targetEnumType, Type targetUnderlyingValue, float value)
+			=> throw new SerializationException($"Cannot convert decoded '{sourceType}' type value to '{targetEnumType}' enum value. Decoded value '{value}' is not in range of valid underlying type '{targetUnderlyingValue}'.");
+		
+		public static void OutOfRangeEnumUnderlyingValue(Type sourceType, Type targetEnumType, Type targetUnderlyingValue, double value)
+			=> throw new SerializationException($"Cannot convert decoded '{sourceType}' type value to '{targetEnumType}' enum value. Decoded value '{value}' is not in range of valid underlying type '{targetUnderlyingValue}'.");
+
+		public static void DecodedTypeIsNotEnum(ElementType elementType, long position)
+			=> throw new SerializationException($"Element type '{elementType}' is not underlying type of enum type at position {position:#,0}.");
+
+		public static void DateTimeSerializerProviderIsNotRegistered(Type targetType)
+			=> throw new SerializationException($"IObjectSerializerProvider for date-time like type '{targetType}' is not registered. It must be registered via SerializerProvider.RegisterDateTimeSerializerProvider in advance.");
+
+		public static void IncompatibleTargetType(Type expected, Type actual)
+			=> throw new SerializationException($"Target type '{actual}' is not assignable to type '{expected}' which is expected type by this provider.");
+
+		public static void DuplicatedSerializedName(string name)
+			=> throw new SerializationException($"A mapping for serialized member name '{name}' is duplicated");
+
+		internal static void TypeIsMappedToMultipleExtensionTypes(Type type, string[] typeCodes)
+			=> throw new SerializationException(
+				$"Type '{type}' is mapped to multiple extension type codes({String.Join(CultureInfo.CurrentCulture.TextInfo.ListSeparator, typeCodes)})."
+			);
+
+		public static void UnknownOriginalName(string name)
+			=> throw new SerializationException($"Original member name '{name}' is not known.");
+
+		public static void UnknownSerializedName(string name)
+			=> throw new SerializationException($"Serialized member name '{name}' is not known.");
+
 		public static void DataMemberAttributeCannotBeZeroWhenOneBoundDataMemberOrderIsTrue(Type declaringType, string? memberName)
 			=> throw new NotSupportedException(
 				$"Cannot specify order value 0 on DataMemberAttribute for '{declaringType}.{memberName}' " +
 				$"when SerializationContext.CompatibilityOptions.OneBoundDataMemberOrder is set to true."
 			);
 
+#warning TODO: Revise messages
+		public static SerializerBuilder ForRuntimeCodeGenerationNotRegistered()
+			=> throw new InvalidOperationException(
+				"Runtime code generation engine is not configured. " +
+				"Ensure that MsgPack.Serialization.ILGeneration package exists and SerializationContextBuilder.UseRuntimeCodeGeneration() extension method was called."
+			);
+
+		public static SerializerBuilder ForReflectionNotRegistered()
+			=> throw new InvalidOperationException(
+				"Reflection engine is not configured. " +
+				"Ensure that MsgPack.Serialization.Reflection package exists and SerializationContextBuilder.UseReflection() extension method was called."
+			);
+
+		public static SerializerBuilder ForSourceCodeGenerationNotRegistered()
+			=> throw new InvalidOperationException(
+				"Source code generation engine is not configured. " +
+				"Ensure that MsgPack.Serialization.SourceGeneration package exists and SerializationContextBuilder.UseSourceCodeGeneration() extension method was called."
+			);
+
 		public static void TypeCannotBeSerializedBecauseNoMembersAndNoParameterizedPublicConstructors(Type targetType)
-			=> new SerializationException(
+			=> throw new SerializationException(
 				$"Cannot serialize type '{targetType}' because it does not have any serializable fields nor properties, " +
 				$"and it does not have any public constructors with parameters."
 			);
 
+		internal static void TargetTypeIsNotDateTimeLikeType(Type targetType, IEnumerable<Type> knownDateTimeTypes)
+			=> throw new InvalidOperationException($"Type '{targetType}' is not known DateTime like type. Allowed types are [{String.Join(", ", knownDateTimeTypes)}] and their nullable wrapper types.");
+
 		public static void TypeCannotBeSerializedBecauseNoMembersAndAmbigiousConstructors(Type targetType, IEnumerable<ConstructorInfo> mostRichConstructors)
 			=> throw new SerializationException(
 				$"Cannot serialize type '{targetType}' because it does not have any serializable fields nor properties, " +
@@ -58,6 +147,9 @@ public static void MemberIsMarkedWithMemberAndIgnoreAttribute(Type type, string
 		public static void TargetDoesNotHavePublicDefaultConstructor(Type targetType)
 			=> throw new SerializationException($"Type '{targetType}' does not have default (parameterless) public constructor.");
 
+		public static void TargetDoesNotHavePublicDefaultConstructorNorInitialCapacity(Type collectionInstanceType)
+			=> throw new SerializationException($"Type '{collectionInstanceType}' does not have default any public collection constructors (.ctor(), .ctor(System.Int32), .ctor(System.Collections.Generic.IEqualityComparer<T>), .ctor(System.Int32, System.Collections.Generic.IEqualityComparer<T>), or .ctor(System.Collections.Generic.IEqualityComparer<T>, System.Int32)).");
+
 		public static void IsNotSerializableAnyway(Type targetType)
 			=> throw new SerializationException($"Cannot serialize type '{targetType}' because it does not have any serializable fields nor properties.");
 
@@ -70,56 +162,99 @@ public static void UnexpectedBinaryType(object? value)
 		public static void UnexpectedStringType(object? value)
 			=> throw new NotSupportedException($"Type '{value?.GetType()}' is unexpected for string value.");
 
+		public static void InvalidDateTimeFormat(ElementType elementType, Type type, long position)
+			 => throw new SerializationException($"Element type '{elementType}' is not valid for serialized '{type}' value at position {position:#,0}.");
+
+		public static void InvalidDateTimeOffsetArray(long position)
+			 => throw new SerializationException($"Array length is not valid for serialized '{typeof(DateTimeOffset)}' value at position {position:#,0}. Valid length is 2.");
+
+		public static void InvalidDateTimeOffsetArray(long length, long position)
+			 => throw new SerializationException($"Array length {length} is not valid for serialized '{typeof(DateTimeOffset)}' value at position {position:#,0}. Valid length is 2.");
+
+		public static void TooLongIso8601FormatString(long length, int maxLength, long position)
+			 => throw new SerializationException($"String length {length} is too long as ISO 8601 extended string at position {position:#,0}. Valid length is less than or equal to {maxLength}.");
+
+		public static void TooLongIso8601FormatString(long length, int maxLength, Encoding encoding, long position)
+			 => throw new SerializationException($"String length {length} is too long as ISO 8601 extended string which is encoded by '{encoding.EncodingName}' at position {position:#,0}. Valid length is less than or equal to {maxLength}.");
+
+		public static void InvalidIso8601FormatString(Span<byte> buffer, long position)
+			 => throw new SerializationException($"String '{StringEscape.Stringify(new ReadOnlySequence<byte>(buffer.ToArray()))}' is not valid as ISO 8601 extended string at position {position:#,0}.");
+
+		public static void InvalidIso8601FormatString(Span<byte> buffer, long position, Exception innerException)
+			 => throw new SerializationException($"String '{StringEscape.Stringify(new ReadOnlySequence<byte>(buffer.ToArray()))}' is not valid as ISO 8601 extended string at position {position:#,0}.", innerException);
+
+		public static void InvalidIso8601FormatString(string value, long position)
+			 => throw new SerializationException($"String '{StringEscape.ForDisplay(value)}' is not valid as ISO 8601 extended string at position {position:#,0}.");
+
 		public static void CannotSerializeNonPublicTypeUnlessPrivledgedAccessEnabled(Type targetType)
-			=> throw new SerializationException($"Cannot serialize type '{targetType}' because it is not public to the serializer.");
+			=> throw new SerializationException($"Cannot serialize type '{targetType}' because it is not public to generating serializer.");
+
+		public static void CannotDetectCorrepondentMemberNameUniquely(ParameterInfo parameterInfo, IEnumerable<string> members)
+			=> throw new AmbiguousMatchException(
+				$"There are multiple candidates for correspondent member for parameter '{parameterInfo}' of constructor. [{String.Join(", ", members)}]"
+			);
 
 		public static void NoConstructorForCollection(Type targetType)
-			=> throw new SerializationException($"Cannot deserialize collection type '{targetType}' because it does not have both of public default constructor and public consctructor with Int32 capacity parameter.");
+			=> throw new SerializationException($"Cannot deserialize collection type '{targetType}' because it does not have both of public default constructor and public consctructor with Int32 type 'capacity' parameter.");
 
-		public static object? UndeserializableCollection(Type targetType)
-			=> throw new NotSupportedException($"A generated serialzier for '{targetType}' does not supprot deserialization because the type does not expose Add method.");
-	}
+		public static void UndeserializableCollection(Type targetType)
+			=> throw new NotSupportedException($"A generated serializer for '{targetType}' does not support deserialization because the type does not expose Add method.");
 
-#warning EXTRACT
-	internal static class DiagnosticsSourceExtensions
-	{
-		private const string Prefix = "MsgPack.Serialization.";
-		private const string PolymorphicPrefix = Prefix + "Polymorphic.";
+		public static void CannotSerializeTypeWhichDeclaresReadOnlySignificantNonCollectionMemberWhenAsymmetricSerializerIsNotAllowed(Type targetType, MemberInfo member)
+			=> throw new SerializationException($"Cannot generate serializer for type '{targetType}' because read-only and non-collection member '{member}' is not ignored, and asymmetric serializer generation is not allowed. The member should be ignored via MessagePackIgnoreAttribute, be settable, or have correspond constructor parameter, or set SerializerGenerationOptionsBuilder.AllowsAsymmetricSerializer 'true'.");
+
+		public static void ExtensionTypeKeyNotFound(string name)
+			=> throw new KeyNotFoundException($"Extension type '{StringEscape.ForDisplay(name)}' is not found.");
+
+		public static void DecodeFailure(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode value at positon {position:#,0}.", ex);
+
+		public static void EncodedTypeMustBeNonNilArray(long position)
+			=> throw new SerializationException($"Type info must be non-nil array at position {position:#,0}.");
+		
+		public static void UnknownTypeEmbedding(long position)
+			=> throw new SerializationException($"Cannot deserialize with type-embedding based serializer. Root object must be 2 element array at position {position:#,0}.");
+
+		public static void EncodedTypeDoesNotHaveValidArrayItems(int required, int actual, long position)
+			=> throw new SerializationException($"Components count of the type info is not valid. {required} is required, but actual value is {actual} at position {position:#,0}.");
+		
+		public static void FailedToDecodeEncodingType(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode 'encode type' component at position {position:#,0}.", ex);
 
-		public static void DeserializationConstructorFound(this DiagnosticSource source, object value)
-			=> source.Write(Prefix + "DeserializationConstructorFound", value);
+		public static void UnknownEncodingType(byte encodeType, long position)
+			=> throw new SerializationException($"Unknown encoded type '{encodeType}' at position {position:#,0}.");
 
-		public static void DetectedAsDeserializable(this DiagnosticSource source, object value)
-			=> source.Write(Prefix + "DetectedAsDeserializable", value);
+		public static void FailedToDecodeCompressedTypeName(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode 'type name' component at position {position:#,0}.", ex);
 
-		public static void DefaultPolymorphicSchemaForValueType(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "DefaultSchemaForValueType", value);
+		public static void FailedToDecodeAssemblySimpleName(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode 'assembly name' component. at position {position:#,0}", ex);
 
-		public static void PolymorphicSchemaCreatedForRootType(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "SchemaCreatedForRootType", value);
+		public static void FailedToDecodeAssemblyVersion(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode 'version' component at position {position:#,0}.", ex);
 
-		public static void DefaultPolymorphicSchemaForUnqualifiedCollectionMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedCollectionMember", value);
+		public static void FailedToDecodeAssemblyVersion(int expectedLength, int actualLength, long position)
+			=> throw new SerializationException($"Failed to decode 'version' component. Expected length is {expectedLength} but actual length is {actualLength} at position {position:#,0}.");
 
-		public static void PolymorphicSchemaCreatedForCollectionMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "SchemaCreatedForCollectionMember", value);
+		public static void FailedToDecodeAssemblyCulture(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode 'culture' component at position {position:#,0}.", ex);
 
-		public static void DefaultPolymorphicSchemaForUnqualifiedDictionaryMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedDictionaryMember", value);
+		public static void FailedToDecodeAssemblyPublicKeyToken(Exception ex, long position)
+			=> throw new SerializationException($"Failed to decode 'public key token' component at position {position:#,0}.", ex);
 
-		public static void PolymorphicSchemaCreatedForDictionaryMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "SchemaCreatedForDictionaryMember", value);
+		public static void FailedToDecodeAssemblyPublicKeyToken(int expectedLength, int actualLength, long position)
+			=> throw new SerializationException($"Failed to decode 'public key token' component. Expected length is {expectedLength} but actual length is {actualLength} at position {position:#,0}.");
 
-		public static void DefaultPolymorphicSchemaForUnqualifiedTupleMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedTupleMember", value);
+		public static void ValueTypeCannotBePolymorphic(Type type)
+			=> throw new SerializationException($"Value type '{type}' cannot be polymorphic.");
 
-		public static void PolymorphicSchemaCreatedForTupleMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "SchemaCreatedForTupleMember", value);
+		public static void CannotGetActualTypeSerializer(Type actualType)
+			=> throw new SerializationException($"Cannot get serializer for actual type {actualType} from serialzier provider.");
 
-		public static void DefaultPolymorphicSchemaForUnqualifiedObjectMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "DefaultSchemaForUnqualifiedObjectMember", value);
+		public static void TypeIsNotDefinedAsKnownType(Type type)
+			=> throw new SerializationException($"Type '{type}' in assembly '{type.Assembly}' is not defined as known types.");
 
-		public static void PolymorphicSchemaCreatedForObjectMember(this DiagnosticSource source, object value)
-			=> source.Write(PolymorphicPrefix + "SchemaCreatedForObjectMember", value);
+		public static void UnknownTypeCode(string typeCode, long position)
+			=> throw new SerializationException($"Unknown type code '{typeCode}' at position {position:#,0}.");
 	}
 }
diff --git a/src/MsgPack.Serialization/Serialization/TypeKeyRepositoryLogics.cs b/src/MsgPack.Serialization/Serialization/TypeKeyRepositoryLogics.cs
new file mode 100644
index 000000000..ef0d10301
--- /dev/null
+++ b/src/MsgPack.Serialization/Serialization/TypeKeyRepositoryLogics.cs
@@ -0,0 +1,50 @@
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+
+namespace MsgPack.Serialization
+{
+	/// <summary>
+	///		Defines common logics for <see cref="TypeKeyRepository"/> compatible implementation.
+	/// </summary>
+	internal static class TypeKeyRepositoryLogics
+	{
+		/// <summary>
+		///		Tries to get matched object for the key or for generic definition of the key from specified dictionary.
+		/// </summary>
+		/// <param name="table">A ditionary which may contain target item.</param>
+		/// <param name="type">Key for extraction.</param>
+		/// <param name="matched">Matched value for <paramref name="type"/> itself. <c>null</c> when not matched.</param>
+		/// <param name="genericDefinitionMatched">Matched value for generic definition of <paramref name="type"/>. <c>null</c> when not matched.</param>
+		/// <returns>
+		///		<c>true</c> when found, that is either <paramref name="matched"/> or <paramref name="genericDefinitionMatched"/> will be non-null value;
+		///		<c>false</c> otherwise, that is both of <paramref name="matched"/> and <paramref name="genericDefinitionMatched"/> are <c>null</c>.
+		///	</returns>
+		public static bool TryGet(IReadOnlyDictionary<RuntimeTypeHandle, object> table, Type type, out object? matched, out object? genericDefinitionMatched)
+		{
+			if (table.TryGetValue(type.TypeHandle, out var result))
+			{
+				matched = result;
+				genericDefinitionMatched = null;
+				return true;
+			}
+
+			if (type.GetIsGenericType())
+			{
+				if (table.TryGetValue(type.GetGenericTypeDefinition().TypeHandle, out result))
+				{
+					matched = null;
+					genericDefinitionMatched = result;
+					return true;
+				}
+			}
+
+			matched = null;
+			genericDefinitionMatched = null;
+			return false;
+		}
+	}
+}
diff --git a/src/MsgPack/Serialization/DateTimeConversionMethod.cs b/src/MsgPack/Serialization/DateTimeConversionMethod.cs
index 9f317fda5..6add8b7b7 100644
--- a/src/MsgPack/Serialization/DateTimeConversionMethod.cs
+++ b/src/MsgPack/Serialization/DateTimeConversionMethod.cs
@@ -9,6 +9,9 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Defines behavior of built-in serializers to conversion of <see cref="DateTime"/> value.
 	/// </summary>
+	/// <remarks>
+	///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+	/// </remarks>
 	public enum DateTimeConversionMethod
 	{
 		/// <summary>
@@ -32,7 +35,7 @@ public enum DateTimeConversionMethod
 		/// </summary>
 		/// <remarks>
 		///		<para>
-		///			As of 1.0, this value became default.
+		///			As of 1.0, this value became default in MsgPack codec.
 		///		</para>
 		///		<para>
 		///			This is best choice for interoperability and prevents accidental data loss, but old implementation does not recognize this type.
@@ -43,6 +46,16 @@ public enum DateTimeConversionMethod
 		///			If you can depend on this assembly, consider <see cref="Timestamp"/> for date-time typed members to maximize interoperability for other languages.
 		///		</para>
 		/// </remarks>
-		Timestamp = 2
+		Timestamp = 2,
+
+		// 3 is reserved for Iso8601BasicFormat
+
+		/// <summary>
+		///		Uses ISO 8601 extended format string, that is, "yyyy-MM-ddTHH:mm:ss.f+Z" format.
+		/// </summary>
+		/// <remarks>
+		///		This value is default in JSON codec and its family.
+		/// </remarks>
+		Iso8601ExtendedFormat = 4
 	}
 }
diff --git a/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs b/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs
index 8ade1933b..8d1d722fe 100644
--- a/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs
+++ b/src/MsgPack/Serialization/DateTimeMemberConversionMethod.cs
@@ -9,6 +9,9 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Defines behavior of built-in serializers to conversion of <see cref="DateTime"/> value for specific member.
 	/// </summary>
+	/// <remarks>
+	///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+	/// </remarks>
 	public enum DateTimeMemberConversionMethod
 	{
 		/// <summary>
@@ -51,6 +54,16 @@ public enum DateTimeMemberConversionMethod
 		///			If you can depend on this assembly, consider <see cref="Timestamp"/> for date-time typed members to maximize interoperability for other languages.
 		///		</para>
 		/// </remarks>
-		Timestamp = 3
+		Timestamp = 3,
+
+		// 3 is reserved for Iso8601BasicFormat
+
+		/// <summary>
+		///		Uses ISO 8601 extended format string, that is, "yyyy-MM-ddTHH:mm:ss.f+Z" format.
+		/// </summary>
+		/// <remarks>
+		///		This value is default in JSON codec and its family.
+		/// </remarks>
+		Iso8601ExtendedFormat = 4
 	}
 }
diff --git a/src/MsgPack/Serialization/KeyNameTransformers.cs b/src/MsgPack/Serialization/KeyNameTransformers.cs
index f24c9b4a9..e7d54f8e1 100644
--- a/src/MsgPack/Serialization/KeyNameTransformers.cs
+++ b/src/MsgPack/Serialization/KeyNameTransformers.cs
@@ -1,106 +1,90 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2016-2018 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Text;
 
 namespace MsgPack.Serialization
 {
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	static class KeyNameTransformers
-	{ 
+	public static class KeyNameTransformers
+	{
 		public static readonly Func<string, string> AsIs = key => key;
 
-		public static string ToLowerCamel( string mayBeUpperCamel )
+		public static readonly Func<string, string> ToLowerCamel = ToLowerCamelCore;
+
+		public static readonly Func<string, string> ToUpperSnake = s => ToSnakeCaseCore(s, toBeUpperCase: true);
+
+		public static readonly Func<string, string> ToLowerSnake = s => ToSnakeCaseCore(s, toBeUpperCase: false);
+
+		private static string ToLowerCamelCore(string mayBeUpperCamel)
 		{
-			if ( String.IsNullOrEmpty( mayBeUpperCamel ) )
+			if (String.IsNullOrEmpty(mayBeUpperCamel))
 			{
 				return mayBeUpperCamel;
 			}
 
-			if ( !Char.IsUpper( mayBeUpperCamel[ 0 ] ) )
+			if (!Char.IsUpper(mayBeUpperCamel[0]))
 			{
 				return mayBeUpperCamel;
 			}
 
-			var buffer = new StringBuilder( mayBeUpperCamel.Length );
-			buffer.Append( Char.ToLowerInvariant( mayBeUpperCamel[ 0 ] ) );
-			if ( mayBeUpperCamel.Length > 1 )
+			var buffer = new StringBuilder(mayBeUpperCamel.Length);
+			buffer.Append(Char.ToLowerInvariant(mayBeUpperCamel[0]));
+			if (mayBeUpperCamel.Length > 1)
 			{
-				buffer.Append( mayBeUpperCamel, 1, mayBeUpperCamel.Length - 1 );
+				buffer.Append(mayBeUpperCamel, 1, mayBeUpperCamel.Length - 1);
 			}
 
 			return buffer.ToString();
 		}
 
-		public static string ToUpperSnake( string mayBeUpperCamel )
+		private static string ToSnakeCaseCore(string mayBeUpperCamel, bool toBeUpperCase)
 		{
-			if ( String.IsNullOrEmpty( mayBeUpperCamel ) )
+			if (String.IsNullOrEmpty(mayBeUpperCamel))
 			{
 				return mayBeUpperCamel;
 			}
 
-			var buffer = new StringBuilder( mayBeUpperCamel.Length * 2 );
+			var buffer = new StringBuilder(mayBeUpperCamel.Length * 2);
 			char previous = '\0';
 			int index = 0;
-			for ( ; index < mayBeUpperCamel.Length; index++ )
+	
+			// Process continuous upper cases in head.
+			for (; index < mayBeUpperCamel.Length; index++)
 			{
-				var c = mayBeUpperCamel[ index ];
-				if ( Char.IsUpper( c ) )
+				var c = mayBeUpperCamel[index];
+				if (Char.IsUpper(c))
 				{
-					buffer.Append( c );
+					buffer.Append(toBeUpperCase ? c : Char.ToLowerInvariant(c));
 					previous = c;
 				}
 				else
 				{
-					buffer.Append( Char.ToUpperInvariant( c ) );
+					buffer.Append(toBeUpperCase ? Char.ToUpperInvariant(c) : c);
 					previous = c;
 					index++;
 					break;
 				}
 			}
 
-			for ( ; index < mayBeUpperCamel.Length; index++ )
+			// Process remaining
+			for (; index < mayBeUpperCamel.Length; index++)
 			{
-				var c = mayBeUpperCamel[ index ];
-				if ( Char.IsUpper( c ) )
+				var c = mayBeUpperCamel[index];
+				if (Char.IsUpper(c))
 				{
-					if ( previous != '_' )
+					if (previous != '_')
 					{
-						buffer.Append( '_' );
+						buffer.Append('_');
 					}
 
-					buffer.Append( c );
+					buffer.Append(toBeUpperCase ? c : Char.ToLowerInvariant(c));
 					previous = c;
 				}
 				else
 				{
-					buffer.Append( Char.ToUpperInvariant( c ) );
+					buffer.Append(toBeUpperCase ? Char.ToUpperInvariant(c) : c);
 					previous = c;
 				}
 			}
diff --git a/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs
index 484cfeebc..d70894bcf 100644
--- a/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackDateTimeMemberAttribute.cs
@@ -7,7 +7,7 @@
 namespace MsgPack.Serialization
 {
 	/// <summary>
-	///		Marks that this <see cref="DateTime"/> or <see cref="DateTimeOffset"/> typed member has special characteristics on MessagePack serialization.
+	///		Marks that this <see cref="DateTime"/>, <see cref="DateTimeOffset"/>, or <see cref="Timestamp"/> typed member has special characteristics on MessagePack serialization.
 	/// </summary>
 	/// <remarks>
 	///		If this attributes is used for incompatible typed members, this attribute will be ignored.
@@ -24,6 +24,38 @@ public sealed class MessagePackDateTimeMemberAttribute : Attribute
 		/// </value>
 		public DateTimeMemberConversionMethod DateTimeConversionMethod { get; set; }
 
+		/// <summary>
+		///		Gets or sets the precision of fraction portion on ISO 8601 date time string.
+		/// </summary>
+		/// <value>
+		///		The precision of fraction portion on ISO 8601 date time string.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="DateTimeConversion"]'/>
+		/// </remarks>
+		public int? Iso8601SubsecondsPrecision { get; set; }
+
+		private char? _iso8601DecimalMark;
+
+		/// <summary>
+		///		Gets or sets the separator char for fraction portion.
+		/// </summary>
+		/// <value>
+		///		The separator char for fraction portion.
+		///		<c>null</c> means that the value will be determined by serialization option or serializer implementation.
+		/// </value>
+		public char? Iso8601DecimalMark
+		{
+			get => this._iso8601DecimalMark;
+			set => this._iso8601DecimalMark = value switch
+			{
+				',' => ',',
+				'.' => '.',
+				_ => Throw.InvalidIso8601DecimalMark(value)
+			};
+		}
+
 		/// <summary>
 		///		Initializes a new instance of the <see cref="MessagePackDateTimeMemberAttribute"/> class.
 		/// </summary>
diff --git a/src/MsgPack/Serialization/MessagePackEnumAttribute.cs b/src/MsgPack/Serialization/MessagePackEnumAttribute.cs
index 05c3ccf9c..84d1f6269 100644
--- a/src/MsgPack/Serialization/MessagePackEnumAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackEnumAttribute.cs
@@ -10,7 +10,8 @@ namespace MsgPack.Serialization
 	///		Marks that this enum type has special characteristics on MessagePack serialization.
 	/// </summary>
 	/// <remarks>
-	///		Enum types which are not marked with this attribute will be serialized as <see cref="SerializationContext.EnumSerializationMethod"/> value.
+	///		Enum types which are not marked with this attribute will be serialized as <see cref="SerializerProvider.EnumSerializationMethod"/> value.
+	///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="EnumSerialization"]'/>
 	/// </remarks>
 	[AttributeUsage(AttributeTargets.Enum, Inherited = false, AllowMultiple = false)]
 	public sealed class MessagePackEnumAttribute : Attribute
@@ -22,6 +23,9 @@ public sealed class MessagePackEnumAttribute : Attribute
 		///		The default serialization method for this enum type.
 		///		Note that the method for individual enum typed members will be overrided with <see cref="MessagePackEnumMemberAttribute"/>.
 		/// </value>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="EnumSerialization"]'/>
+		/// </remarks>
 		public EnumSerializationMethod SerializationMethod { get; set; }
 
 		/// <summary>
diff --git a/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs
index 7a9f4661f..d443a1154 100644
--- a/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackEnumMemberAttribute.cs
@@ -11,6 +11,7 @@ namespace MsgPack.Serialization
 	/// </summary>
 	/// <remarks>
 	///		If this attributes is used for non-enum typed members, this attribute will be ignored.
+	///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="EnumSerialization"]'/>
 	/// </remarks>
 	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
 	public sealed class MessagePackEnumMemberAttribute : Attribute
@@ -22,6 +23,9 @@ public sealed class MessagePackEnumMemberAttribute : Attribute
 		///		The default serialization method for this enum typed member.
 		///		Note that the method for the enum type will be overrided with this.
 		/// </value>
+		/// <remarks>
+		///		<include file='../../Common/Remarks.xml' path='docs/doc[@name="EnumSerialization"]'/>
+		/// </remarks>
 		public EnumMemberSerializationMethod SerializationMethod { get; set; }
 
 		/// <summary>
diff --git a/src/MsgPack/Serialization/MessagePackMemberAttribute.cs b/src/MsgPack/Serialization/MessagePackMemberAttribute.cs
index a5608da56..6d7d0ce8c 100644
--- a/src/MsgPack/Serialization/MessagePackMemberAttribute.cs
+++ b/src/MsgPack/Serialization/MessagePackMemberAttribute.cs
@@ -19,10 +19,10 @@ namespace MsgPack.Serialization
 	public sealed class MessagePackMemberAttribute : Attribute
 	{
 		/// <summary>
-		///		Gets the ID of the member.
+		///		Gets the ID of this member.
 		/// </summary>
 		/// <value>
-		///		The ID of the member.
+		///		The ID of this member. This value will be array index on serialized stream.
 		/// </value>
 		public int Id { get; }
 
@@ -30,17 +30,18 @@ public sealed class MessagePackMemberAttribute : Attribute
 		///		Gets or sets the name of this member.
 		/// </summary>
 		/// <value>
-		///		The name which will be used in map key on serialized MessagePack stream.
+		///		The name which will be used in map key on serialized stream.
+		///		If this value is not specified, the qualified member's name will be used.
 		/// </value>
 		public string? Name { get; set; }
 
 		private NilImplication _nilImplication;
 
 		/// <summary>
-		///		Gets or sets the implication of the nil value.
+		///		Gets or sets the implication of nil value.
 		/// </summary>
 		/// <value>
-		///		The implication of the nil value.
+		///		The implication of nil value.
 		///		Default value is <see cref="F:NilImplication.MemberDefault"/>.
 		/// </value>
 		public NilImplication NilImplication
diff --git a/src/MsgPack/Serialization/Polymorphic/TypeInfoEncoder.cs b/src/MsgPack/Serialization/Polymorphic/TypeInfoEncoder.cs
index 592ddef4d..87c3cc553 100644
--- a/src/MsgPack/Serialization/Polymorphic/TypeInfoEncoder.cs
+++ b/src/MsgPack/Serialization/Polymorphic/TypeInfoEncoder.cs
@@ -1,349 +1,884 @@
-#region -- License Terms --
-// 
-// MessagePack for CLI
-// 
-// Copyright (C) 2015-2018 FUJIWARA, Yusuke
-// 
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-// 
-//        http://www.apache.org/licenses/LICENSE-2.0
-// 
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-// 
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
+using System.Buffers;
+using System.Buffers.Binary;
 using System.Globalization;
 using System.Reflection;
-using System.Runtime.Serialization;
-#if FEATURE_TAP
-using System.Threading;
 using System.Threading.Tasks;
-#endif // FEATURE_TAP
+using MsgPack.Internal;
 
 namespace MsgPack.Serialization.Polymorphic
 {
 	/// <summary>
 	/// 	Implements type info encoding for type embedding.
 	/// </summary>
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	static class TypeInfoEncoder
+	internal static class TypeInfoEncoder
 	{
+		public delegate T Deserialization<T>(Type decodedType, ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+		public delegate Type TypeDecoding(ref DeserializationOperationContext context, ref SequenceReader<byte> source);
+
 		private const string Elipsis = ".";
 
-		public static void Encode( Packer packer, string typeCode )
+		public static void EncodeStart(ref SerializationOperationContext context, IBufferWriter<byte> writer, string typeCode)
 		{
-			packer.PackArrayHeader( 2 );
-			packer.PackString( typeCode );
+			var encoder = context.Encoder;
+
+			context.IncrementDepth();
+			var collectionContext = context.CollectionContext;
+			encoder.EncodeArrayStart(2, writer, collectionContext);
+			encoder.EncodeArrayItemStart(0, writer, context.CollectionContext);
+			encoder.EncodeString(typeCode, writer, context.Options.DefaultStringEncoding, context.CancellationToken);
+			encoder.EncodeArrayItemEnd(0, writer, context.CollectionContext);
+			encoder.EncodeArrayItemStart(1, writer, context.CollectionContext);
 		}
 
-#if FEATURE_TAP
-
-		public static async Task EncodeAsync( Packer packer, string typeCode, CancellationToken cancellationToken )
+		public static void EncodeEnd(ref SerializationOperationContext context, IBufferWriter<byte> writer)
 		{
-			await packer.PackArrayHeaderAsync( 2, cancellationToken ).ConfigureAwait( false );
-			await packer.PackStringAsync( typeCode, cancellationToken ).ConfigureAwait( false );
-		}
+			var encoder = context.Encoder;
 
-#endif // FEATURE_TAP
+			encoder.EncodeArrayItemEnd(1, writer, context.CollectionContext);
+			encoder.EncodeArrayEnd(2, writer, context.CollectionContext);
+			context.DecrementDepth();
+		}
 
-		public static void Encode( Packer packer, Type type )
+		public static void EncodeStart(ref SerializationOperationContext context, IBufferWriter<byte> writer, Type type)
 		{
-			var assemblyName =
-#if !SILVERLIGHT
-				type.GetAssembly().GetName();
-#else
-				new AssemblyName( type.GetAssembly().FullName );
-#endif // !SILVERLIGHT
+			var encoder = context.Encoder;
+
+			var assemblyName = new AssemblyName(type.GetAssembly().FullName!);
 
-			packer.PackArrayHeader( 2 );
-			packer.PackArrayHeader( 6 );
+			context.IncrementDepth();
+			encoder.EncodeArrayStart(2, writer, context.CollectionContext);
+			context.IncrementDepth();
+			encoder.EncodeArrayItemStart(0, writer, context.CollectionContext);
+			encoder.EncodeArrayStart(6, writer, context.CollectionContext);
 
-			packer.Pack( ( byte )TypeInfoEncoding.RawCompressed );
+			encoder.EncodeArrayItemStart(0, writer, context.CollectionContext);
+			encoder.EncodeUInt32((byte)TypeInfoEncoding.RawCompressed, writer);
+			encoder.EncodeArrayItemEnd(0, writer, context.CollectionContext);
 
 			// Omit namespace prefix when it equals to declaring assembly simple name.
 			var compressedTypeName =
-				( type.Namespace != null && type.Namespace.StartsWith( assemblyName.Name, StringComparison.Ordinal ) )
-					? Elipsis + type.FullName.Substring( assemblyName.Name.Length + 1 )
+				(type.Namespace != null && type.Namespace.StartsWith(assemblyName.Name!, StringComparison.Ordinal))
+					? Elipsis + type.FullName!.Substring(assemblyName.Name!.Length + 1)
 					: type.FullName;
-			var version = new byte[ 16 ];
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Major ), 0, version, 0, 4 );
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Minor ), 0, version, 4, 4 );
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Build ), 0, version, 8, 4 );
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Revision ), 0, version, 12, 4 );
-
-			packer
-				.PackString( compressedTypeName )
-				.PackString( assemblyName.Name )
-				.PackBinary( version )
-				.PackString( assemblyName.GetCultureName() )
-				.PackBinary( assemblyName.GetPublicKeyToken() );
+			Span<byte> version = stackalloc byte[16];
+			BinaryPrimitives.WriteInt32LittleEndian(version, assemblyName.Version!.Major);
+			BinaryPrimitives.WriteInt32LittleEndian(version.Slice(sizeof(int)), assemblyName.Version.Minor);
+			BinaryPrimitives.WriteInt32LittleEndian(version.Slice(sizeof(int) * 2), assemblyName.Version.Build);
+			BinaryPrimitives.WriteInt32LittleEndian(version.Slice(sizeof(int) * 3), assemblyName.Version.Revision);
+
+			encoder.EncodeArrayItemStart(1, writer, context.CollectionContext);
+			encoder.EncodeString(compressedTypeName, writer, context.Options.DefaultStringEncoding, context.CancellationToken);
+			encoder.EncodeArrayEnd(1, writer, context.CollectionContext);
+			encoder.EncodeArrayItemStart(2, writer, context.CollectionContext);
+			encoder.EncodeString(assemblyName.Name, writer, context.Options.DefaultStringEncoding, context.CancellationToken);
+			encoder.EncodeArrayEnd(2, writer, context.CollectionContext);
+			encoder.EncodeArrayItemStart(3, writer, context.CollectionContext);
+			encoder.EncodeBinary(version, writer, context.CancellationToken);
+			encoder.EncodeArrayEnd(3, writer, context.CollectionContext);
+			encoder.EncodeArrayItemStart(4, writer, context.CollectionContext);
+			encoder.EncodeString(assemblyName.GetCultureName(), writer, context.Options.DefaultStringEncoding, context.CancellationToken);
+			encoder.EncodeArrayEnd(4, writer, context.CollectionContext);
+			encoder.EncodeArrayItemStart(5, writer, context.CollectionContext);
+			encoder.EncodeBinary(assemblyName.GetPublicKeyToken(), writer, context.CancellationToken);
+			encoder.EncodeArrayEnd(5, writer, context.CollectionContext);
+			context.DecrementDepth();
+			encoder.EncodeArrayItemEnd(0, writer, context.CollectionContext);
 		}
 
-#if FEATURE_TAP
-
-		public static async Task EncodeAsync( Packer packer, Type type, CancellationToken cancellationToken )
+		public static T Decode<T>(
+			ref DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			Func<string, long, Type> typeFinder,
+			Deserialization<T> deserialization
+		)
 		{
-			var assemblyName = type.GetAssembly().GetName();
+			var decoder = context.Decoder;
+			var initialPosition = source.Consumed;
+			long typeCodePosition;
+			string? typeCode;
 
-			await packer.PackArrayHeaderAsync( 2, cancellationToken ).ConfigureAwait( false );
-			await packer.PackArrayHeaderAsync( 6, cancellationToken ).ConfigureAwait( false );
+			context.IncrementDepth();
+			try
+			{
+				CollectionItemIterator iterator = default;
+				var canOmitIterator = decoder.Options.Features.CanCountCollectionItems;
+				if (canOmitIterator)
+				{
+					if (decoder.DecodeArrayOrMapHeader(ref source, out var itemsCount) != CollectionType.Array || itemsCount != 2)
+					{
+						Throw.UnknownTypeEmbedding(initialPosition);
+					}
+				}
+				else
+				{
+					if (decoder.DecodeArrayOrMap(ref source, out iterator) != CollectionType.Array)
+					{
+						Throw.UnknownTypeEmbedding(initialPosition);
+					}
+				}
 
-			await packer.PackAsync( ( byte )TypeInfoEncoding.RawCompressed, cancellationToken ).ConfigureAwait( false );
+				typeCodePosition = source.Consumed;
+				typeCode = decoder.DecodeString(ref source, context.Options.DefaultStringEncoding, context.CancellationToken);
+				if (!canOmitIterator)
+				{
+					if (iterator.CollectionEnds(ref source) || !iterator.CollectionEnds(ref source))
+					{
+						Throw.UnknownTypeEmbedding(initialPosition);
+					}
+				}
+			}
+			catch (DecodeException ex)
+			{
+				Throw.DecodeFailure(ex);
+				return default!; // Never reaches
+			}
 
-			// Omit namespace prefix when it equals to declaring assembly simple name.
-			var compressedTypeName =
-				( type.Namespace != null && type.Namespace.StartsWith( assemblyName.Name, StringComparison.Ordinal ) )
-					? Elipsis + type.FullName.Substring( assemblyName.Name.Length + 1 )
-					: type.FullName;
-			var version = new byte[ 16 ];
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Major ), 0, version, 0, 4 );
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Minor ), 0, version, 4, 4 );
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Build ), 0, version, 8, 4 );
-			Buffer.BlockCopy( BitConverter.GetBytes( assemblyName.Version.Revision ), 0, version, 12, 4 );
-
-			await packer.PackStringAsync( compressedTypeName, cancellationToken ).ConfigureAwait( false );
-			await packer.PackStringAsync( assemblyName.Name, cancellationToken ).ConfigureAwait( false );
-			await packer.PackBinaryAsync( version, cancellationToken ).ConfigureAwait( false );
-			await packer.PackStringAsync( assemblyName.GetCultureName(), cancellationToken ).ConfigureAwait( false );
-			await packer.PackBinaryAsync( assemblyName.GetPublicKeyToken(), cancellationToken ).ConfigureAwait( false );
+			var type = typeFinder(typeCode, typeCodePosition);
+			var result = deserialization(type, ref context, ref source);
+			context.DecrementDepth();
+			return result;
 		}
-#endif // FEATURE_TAP
 
-		public static T Decode<T>( Unpacker unpacker, Func<string, Type> typeFinder, Func<Type, Unpacker, T> unpacking )
+		public static T Decode<T>(
+			ref DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			TypeDecoding typeDecoding,
+			Deserialization<T> deserialization
+		)
 		{
-			if ( !unpacker.IsArrayHeader || UnpackHelpers.GetItemsCount( unpacker ) != 2 )
+			var decoder = context.Decoder;
+			var position = source.Consumed;
+
+			context.IncrementDepth();
+			CollectionItemIterator iterator = default;
+			var canOmitIterator = decoder.Options.Features.CanCountCollectionItems;
+			if (canOmitIterator)
 			{
-				throw SerializationExceptions.NewUnknownTypeEmbedding();
+				if (decoder.DecodeArrayOrMapHeader(ref source, out var itemsCount) != CollectionType.Array || itemsCount != 2)
+				{
+					Throw.UnknownTypeEmbedding(position);
+				}
 			}
-
-			using ( var subTreeUnpacker = unpacker.ReadSubtree() )
+			else
 			{
-				string typeCode;
-				if ( !subTreeUnpacker.ReadString( out typeCode ) )
+				if (decoder.DecodeArrayOrMap(ref source, out iterator) != CollectionType.Array)
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.UnknownTypeEmbedding(position);
 				}
+			}
 
-				var type = typeFinder( typeCode );
+			var type = typeDecoding(ref context, ref source);
 
-				if ( !subTreeUnpacker.Read() )
+			if (!canOmitIterator)
+			{
+				if (iterator.CollectionEnds(ref source))
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.UnknownTypeEmbedding(position);
 				}
+			}
+
+			var result = deserialization(type, ref context, ref source);
 
-				return unpacking( type, subTreeUnpacker );
+			if (!canOmitIterator)
+			{
+				position = source.Consumed;
+				if (!iterator.CollectionEnds(ref source))
+				{
+					Throw.UnknownTypeEmbedding(position);
+				}
 			}
+
+			context.DecrementDepth();
+			return result;
 		}
 
-		public static T Decode<T>( Unpacker unpacker, Func<Unpacker, Type> typeDecoder, Func<Type, Unpacker, T> unpacking )
+		public static unsafe Type DecodeRuntimeTypeInfo(
+			ref DeserializationOperationContext context,
+			ref SequenceReader<byte> source,
+			Func<PolymorphicTypeVerificationContext, bool> typeVerifier
+		)
 		{
-			if ( !unpacker.IsArrayHeader || UnpackHelpers.GetItemsCount( unpacker ) != 2 )
+			var decoder = context.Decoder;
+			var canOmitIterator = decoder.Options.Features.CanCountCollectionItems;
+			var initialPosition = source.Consumed;
+			CollectionItemIterator iterator;
+
+			var itemsCount = 0;
+
+			context.IncrementDepth();
+			if (canOmitIterator)
 			{
-				throw SerializationExceptions.NewUnknownTypeEmbedding();
+				if (decoder.DecodeArrayOrMapHeader(ref source, out itemsCount) != CollectionType.Array)
+				{
+					Throw.EncodedTypeMustBeNonNilArray(initialPosition);
+				}
+
+				if (itemsCount != 6)
+				{
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
+				}
+
+				iterator = default;
+			}
+			else
+			{
+				if (decoder.DecodeArrayOrMap(ref source, out iterator) != CollectionType.Array)
+				{
+					Throw.EncodedTypeMustBeNonNilArray(initialPosition);
+				}
 			}
 
-			using ( var subTreeUnpacker = unpacker.ReadSubtree() )
+			if (!canOmitIterator)
 			{
-				if ( !subTreeUnpacker.Read() )
+				if (iterator.CollectionEnds(ref source))
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
 				}
 
-				var type = typeDecoder( subTreeUnpacker );
+				itemsCount++;
+			}
+
+			var position = source.Consumed;
+			byte encodeType;
+			try
+			{
+				encodeType = decoder.DecodeByte(ref source);
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeEncodingType(ex, position);
+				encodeType = default; // Never reaches
+			}
+
+			if (encodeType != (byte)TypeInfoEncoding.RawCompressed)
+			{
+				Throw.UnknownEncodingType(encodeType, position);
+			}
 
-				if ( !subTreeUnpacker.Read() )
+			if (!canOmitIterator)
+			{
+				if (iterator.CollectionEnds(ref source))
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
 				}
 
-				return unpacking( type, subTreeUnpacker );
+				itemsCount++;
 			}
-		}
 
-#if FEATURE_TAP
+			position = source.Consumed;
+			string compressedTypeName;
+			try
+			{
+				compressedTypeName = decoder.DecodeString(ref source, context.Options.DefaultStringEncoding, context.CancellationToken);
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeCompressedTypeName(ex, position);
+				compressedTypeName = default!; // Never reaches
+			}
 
-		public static async Task<T> DecodeAsync<T>( Unpacker unpacker, Func<string, Type> typeFinder, Func<Type, Unpacker, CancellationToken, Task<object>> unpackingAsync, CancellationToken cancellationToken )
-		{
-			if ( !unpacker.IsArrayHeader || UnpackHelpers.GetItemsCount( unpacker ) != 2 )
+			if (!canOmitIterator)
 			{
-				throw SerializationExceptions.NewUnknownTypeEmbedding();
+				if (iterator.CollectionEnds(ref source))
+				{
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
+				}
+
+				itemsCount++;
 			}
 
-			using ( var subTreeUnpacker = unpacker.ReadSubtree() )
+			position = source.Consumed;
+			string assemblySimpleName;
+			try
 			{
-				var typeCode = await subTreeUnpacker.ReadStringAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !typeCode.Success )
+				assemblySimpleName = decoder.DecodeString(ref source, context.Options.DefaultStringEncoding, context.CancellationToken);
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeAssemblySimpleName(ex, position);
+				assemblySimpleName = default!; // Never reaches
+			}
+
+			if (!canOmitIterator)
+			{
+				if (iterator.CollectionEnds(ref source))
+				{
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
+				}
+
+				itemsCount++;
+			}
+
+			position = source.Consumed;
+			// Workaround for C# escape analysis bug.
+			byte* pVersion = stackalloc byte[16];
+			var version = new Span<byte>(pVersion, 16);
+			try
+			{
+				var length = decoder.DecodeBinary(ref source, version, context.CancellationToken);
+				if (length != version.Length)
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.FailedToDecodeAssemblyVersion(version.Length, length, position);
 				}
 
-				var type = typeFinder( typeCode.Value );
+				version = version.Slice(0, length);
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeAssemblyVersion(ex, position);
+				version = default; // Never reaches
+			}
+
+			if (!canOmitIterator)
+			{
+				if (iterator.CollectionEnds(ref source))
+				{
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
+				}
+
+				itemsCount++;
+			}
+
+			position = source.Consumed;
+			string? culture;
+			try
+			{
+				culture = decoder.DecodeNullableString(ref source, context.Options.DefaultStringEncoding, context.CancellationToken);
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeAssemblyCulture(ex, position);
+				culture = default; // Never reaches
+			}
 
-				if ( !await subTreeUnpacker.ReadAsync( cancellationToken ).ConfigureAwait( false ) )
+			if (!canOmitIterator)
+			{
+				if (iterator.CollectionEnds(ref source))
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
 				}
 
-				return ( T )await unpackingAsync( type, subTreeUnpacker, cancellationToken ).ConfigureAwait( false );
+				itemsCount++;
+			}
+
+			position = source.Consumed;
+			// Workaround for C# escape analysis bug.
+			byte* pPublicKeyToken = stackalloc byte[8];
+			var publicKeyToken = new Span<byte>(pPublicKeyToken, 8);
+			try
+			{
+				var length = decoder.DecodeNullableBinary(ref source, publicKeyToken, context.CancellationToken);
+				if (length is null)
+				{
+					publicKeyToken = default;
+				}
+				else
+				{
+					if (length != null && length.GetValueOrDefault() != publicKeyToken.Length)
+					{
+						Throw.FailedToDecodeAssemblyPublicKeyToken(publicKeyToken.Length, length.GetValueOrDefault(), position);
+					}
+				}
 			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeAssemblyPublicKeyToken(ex, position);
+				publicKeyToken = default; // Never reaches
+			}
+
+			if (!canOmitIterator)
+			{
+				while (!iterator.CollectionEnds(ref source))
+				{
+					itemsCount++;
+				}
+
+				if (itemsCount != 6)
+				{
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
+				}
+			}
+
+			context.DecrementDepth();
+
+			var assemblyName = BuildAssemblyName(assemblySimpleName, version, culture, publicKeyToken);
+			var typeFullName = DecompressTypeName(assemblyName.Name!, compressedTypeName);
+			RuntimeTypeVerifier.Verify(assemblyName, typeFullName, typeVerifier);
+
+			return LoadDecodedType(assemblyName, typeFullName);
 		}
 
-		public static async Task<T> DecodeAsync<T>( Unpacker unpacker, Func<Unpacker, CancellationToken, Task<Type>> asyncTypeDecoder, Func<Type, Unpacker, CancellationToken, Task<object>> unpackingAsync, CancellationToken cancellationToken )
+#if FEATURE_TAP
+		public static async ValueTask<T> DecodeAsync<T>(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			Func<string, long, Type> typeFinder,
+			Func<Type, AsyncDeserializationOperationContext, ReadOnlyStreamSequence, ValueTask<T>> asyncDeserialization
+		)
 		{
-			if ( !unpacker.IsArrayHeader || UnpackHelpers.GetItemsCount( unpacker ) != 2 )
+			var decoder = context.Decoder;
+			var initialPosition = source.Position;
+
+			var requestHint = 0;
+			CollectionType arrayOrMap;
+			int itemsCount;
+			CollectionItemIterator iterator;
+			var canOmitIterator = context.Decoder.Options.Features.CanCountCollectionItems;
+
+			context.IncrementDepth();
+			while (!TryDecodeArrayOrMap(context, source, canOmitIterator, out itemsCount, out arrayOrMap, out iterator, out requestHint))
+			{
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
+
+			if (arrayOrMap != CollectionType.Array)
 			{
-				throw SerializationExceptions.NewUnknownTypeEmbedding();
+				Throw.UnknownTypeEmbedding(initialPosition);
 			}
 
-			using ( var subTreeUnpacker = unpacker.ReadSubtree() )
+			if (canOmitIterator)
 			{
-				if ( !await subTreeUnpacker.ReadAsync( cancellationToken ).ConfigureAwait( false ) )
+				if (itemsCount != 2)
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.UnknownTypeEmbedding(source.Position);
 				}
+			}
+			else
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+			}
 
-				var type = await asyncTypeDecoder( subTreeUnpacker, cancellationToken ).ConfigureAwait( false );
+			var typeCodePosition = source.Position;
+			string typeCode;
+			while (!TryDecodeString(context, source, out typeCode, out requestHint))
+			{
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
 
-				if ( !await subTreeUnpacker.ReadAsync( cancellationToken ).ConfigureAwait( false ) )
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+			}
+
+			var type = typeFinder(typeCode, typeCodePosition);
+			var result = await asyncDeserialization(type, context, source).ConfigureAwait(false);
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorEndsAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+			}
+			context.DecrementDepth();
+			return result;
+		}
+
+		public static async ValueTask<T> DecodeAsync<T>(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			Func<AsyncDeserializationOperationContext, ReadOnlyStreamSequence, ValueTask<Type>> asyncTypeDecoding,
+			Func<Type, AsyncDeserializationOperationContext, ReadOnlyStreamSequence, ValueTask<T>> asyncDeserialization
+		)
+		{
+			int requestHint;
+			CollectionType arrayOrMap;
+			int itemsCount;
+			CollectionItemIterator iterator;
+			var canOmitIterator = context.Decoder.Options.Features.CanCountCollectionItems;
+
+			var initialPotision = source.Position;
+
+			context.IncrementDepth();
+			while (!TryDecodeArrayOrMap(context, source, canOmitIterator, out itemsCount, out arrayOrMap, out iterator, out requestHint))
+			{
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
+
+			if (arrayOrMap != CollectionType.Array)
+			{
+				Throw.UnknownTypeEmbedding(initialPotision);
+			}
+
+			if (canOmitIterator)
+			{
+				if (itemsCount != 2)
 				{
-					SerializationExceptions.ThrowUnexpectedEndOfStream( subTreeUnpacker );
+					Throw.UnknownTypeEmbedding(initialPotision);
 				}
+			}
 
-				return ( T )await unpackingAsync( type, subTreeUnpacker, cancellationToken ).ConfigureAwait( false );
+			var type = await asyncTypeDecoding(context, source).ConfigureAwait(false);
+
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPotision).ConfigureAwait(false);
 			}
-		}
 
-#endif // FEATURE_TAP
+			var result = await asyncDeserialization(type, context, source).ConfigureAwait(false);
 
-		public static Type DecodeRuntimeTypeInfo( Unpacker unpacker, Func<PolymorphicTypeVerificationContext, bool> typeVerifier )
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorEndsAsync(context, source, iterator, initialPotision).ConfigureAwait(false);
+			}
+
+			context.DecrementDepth();
+			return result;
+		}
+
+		public static async ValueTask<Type> DecodeRuntimeTypeInfoAsync(
+			AsyncDeserializationOperationContext context,
+			ReadOnlyStreamSequence source,
+			Func<PolymorphicTypeVerificationContext, bool> typeVerifier
+		)
 		{
-			CheckUnpackerForRuntimeTypeInfoDecoding( unpacker );
+			var decoder = context.Decoder;
+			var initialPosition = source.Position;
+			var canOmitIterator = decoder.Options.Features.CanCountCollectionItems;
 
-			using ( var subTreeUnpacker = unpacker.ReadSubtree() )
+			context.IncrementDepth();
+			var itemsCount = 0;
+			int requestHint;
+			CollectionType arrayOrMap;
+			CollectionItemIterator iterator;
+
+			while (!TryDecodeArrayOrMap(context, source, canOmitIterator, out itemsCount, out arrayOrMap, out iterator, out requestHint))
 			{
-				byte encodeType;
-				if ( !subTreeUnpacker.ReadByte( out encodeType ) )
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
+
+			if (arrayOrMap != CollectionType.Array)
+			{
+				Throw.EncodedTypeMustBeNonNilArray(initialPosition);
+			}
+
+			if (canOmitIterator)
+			{
+				if (itemsCount != 6)
 				{
-					ThrowFailedToDecodeEncodingType();
+					Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
 				}
+			}
 
-				if ( encodeType != ( byte )TypeInfoEncoding.RawCompressed )
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+				itemsCount++;
+			}
+
+			byte encodeType;
+			try
+			{
+				while (!TryDecodeByte(context, source, out encodeType, out requestHint))
 				{
-					ThrowUnknownEncodingType( encodeType );
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 				}
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeEncodingType(ex, source.Position);
+				encodeType = default; // Never reaches
+			}
+
+			if (encodeType != (byte)TypeInfoEncoding.RawCompressed)
+			{
+				Throw.UnknownEncodingType(encodeType, source.Position);
+			}
+
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+				itemsCount++;
+			}
 
-				string compressedTypeName;
-				if ( !subTreeUnpacker.ReadString( out compressedTypeName ) )
+			string compressedTypeName;
+			try
+			{
+				while (!TryDecodeString(context, source, out compressedTypeName, out requestHint))
 				{
-					ThrowFailedToDecodeCompressedTypeName();
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 				}
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeCompressedTypeName(ex, source.Position);
+				compressedTypeName = default!; // Never reaches
+			}
 
-				string assemblySimpleName;
-				if ( !subTreeUnpacker.ReadString( out assemblySimpleName ) )
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+				itemsCount++;
+			}
+
+			string assemblySimpleName;
+			try
+			{
+				while (!TryDecodeString(context, source, out assemblySimpleName, out requestHint))
 				{
-					ThrowFailedToDecodeAssemblySimpleName();
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
 				}
+			}
+			catch (Exception ex)
+			{
+				Throw.FailedToDecodeAssemblySimpleName(ex, source.Position);
+				assemblySimpleName = default!; // Never reaches
+			}
 
-				byte[] version;
-				if ( !subTreeUnpacker.ReadBinary( out version ) )
+			if (!canOmitIterator)
+			{
+				await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+				itemsCount++;
+			}
+
+			// Workaround for C# escape analysis bug.
+			var version = context.ByteBufferPool.Rent(16);
+			try
+			{
+				try
+				{
+					while (!TryDecodeBinaryTo(context, source, version, out requestHint, (expected, actual, position) => Throw.FailedToDecodeAssemblyVersion(expected, actual, position)))
+					{
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+				catch (Exception ex)
 				{
-					ThrowFailedToDecodeAssemblyVersion();
+					Throw.FailedToDecodeAssemblyVersion(ex, source.Position);
 				}
 
-				string culture;
-				if ( !subTreeUnpacker.ReadString( out culture ) )
+				if (!canOmitIterator)
 				{
-					ThrowFailedToDecodeAssemblyCulture();
+					await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+					itemsCount++;
 				}
 
-				byte[] publicKeyToken;
-				if ( !subTreeUnpacker.ReadBinary( out publicKeyToken ) )
+				string? culture;
+				try
 				{
-					ThrowFailedToDecodeAssemblyKeyToken();
+					while (!TryDecodeNullableString(context, source, out culture, out requestHint))
+					{
+						await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+					}
+				}
+				catch (Exception ex)
+				{
+					Throw.FailedToDecodeAssemblyCulture(ex, source.Position);
+					culture = default; // Never reaches
 				}
 
-				var assemblyName = BuildAssemblyName( assemblySimpleName, version, culture, publicKeyToken );
-				var typeFullName = DecompressTypeName( assemblyName.Name, compressedTypeName );
-				RuntimeTypeVerifier.Verify( assemblyName, typeFullName, typeVerifier );
+				if (!canOmitIterator)
+				{
+					await EnsureIteratorHasNextAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+					itemsCount++;
+				}
 
-				return LoadDecodedType( assemblyName, typeFullName );
+				// Workaround for C# escape analysis bug.
+				var publicKeyToken = context.ByteBufferPool.Rent(8);
+				try
+				{
+					try
+					{
+						while (true)
+						{
+							var nullOrDecoded = TryDecodeNullableBinaryTo(context, source, publicKeyToken, out requestHint, (expected, actual, position) => Throw.FailedToDecodeAssemblyPublicKeyToken(expected, actual, position));
+							if (nullOrDecoded.GetValueOrDefault(true))
+							{
+								break;
+							}
+
+							await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+						}
+					}
+					catch (Exception ex)
+					{
+						Throw.FailedToDecodeAssemblyPublicKeyToken(ex, source.Position);
+					}
+
+					if (!canOmitIterator)
+					{
+						await EnsureIteratorEndsAsync(context, source, iterator, initialPosition).ConfigureAwait(false);
+
+						if (itemsCount != 6)
+						{
+							Throw.EncodedTypeDoesNotHaveValidArrayItems(6, itemsCount, initialPosition);
+						}
+					}
+
+					context.DecrementDepth();
+
+					var assemblyName = BuildAssemblyName(assemblySimpleName, version, culture, publicKeyToken);
+					var typeFullName = DecompressTypeName(assemblyName.Name!, compressedTypeName);
+					RuntimeTypeVerifier.Verify(assemblyName, typeFullName, typeVerifier);
+
+					return LoadDecodedType(assemblyName, typeFullName);
+				}
+				finally
+				{
+					context.ByteBufferPool.Return(publicKeyToken, clearArray: context.Options.ClearsByteBufferOnReturn);
+				}
+			}
+			finally
+			{
+				context.ByteBufferPool.Return(version, clearArray: context.Options.ClearsByteBufferOnReturn);
 			}
 		}
 
-		private static void ThrowFailedToDecodeEncodingType()
+		private static bool TryDecodeArrayOrMap(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, bool canOmitIterator, out int itemsCount, out CollectionType arrayOrMap, out CollectionItemIterator propertyIterator, out int requestHint)
 		{
-			throw new SerializationException( "Failed to decode encode type component." );
-		}
+			var reader = new SequenceReader<byte>(source.Sequence);
 
-		private static void ThrowUnknownEncodingType( byte encodeType )
-		{
-			throw new SerializationException( String.Format( CultureInfo.InvariantCulture, "Unknown encoded type : {0}", encodeType ) );
-		}
+			if (canOmitIterator)
+			{
+				arrayOrMap = context.Decoder.DecodeArrayOrMapHeader(ref reader, out itemsCount, out requestHint);
+				propertyIterator = default;
+			}
+			else
+			{
+				arrayOrMap = context.Decoder.DecodeArrayOrMap(ref reader, out propertyIterator, out requestHint);
+				itemsCount = -1;
+			}
 
-		private static void ThrowFailedToDecodeCompressedTypeName()
-		{
-			throw new SerializationException( "Failed to decode type name component." );
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+
+			return true;
 		}
 
-		private static void ThrowFailedToDecodeAssemblySimpleName()
+		private static bool TryDecodeByte(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out byte value, out int requestHint)
 		{
-			throw new SerializationException( "Failed to decode assembly name component." );
+			var reader = new SequenceReader<byte>(source.Sequence);
+
+			value = context.Decoder.DecodeByte(ref reader, out requestHint)!;
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+
+			return true;
 		}
 
-		private static void ThrowFailedToDecodeAssemblyVersion()
+		private static bool TryDecodeString(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out string value, out int requestHint)
 		{
-			throw new SerializationException( "Failed to decode version component." );
+			var reader = new SequenceReader<byte>(source.Sequence);
+
+			value = context.Decoder.DecodeString(ref reader, out requestHint, context.Options.DefaultStringEncoding, context.CancellationToken)!;
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+
+			return true;
 		}
 
-		private static void ThrowFailedToDecodeAssemblyCulture()
+		private static bool TryDecodeNullableString(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, out string? value, out int requestHint)
 		{
-			throw new SerializationException( "Failed to decode culture component." );
+			var reader = new SequenceReader<byte>(source.Sequence);
+
+			value = context.Decoder.DecodeNullableString(ref reader, out requestHint, context.Options.DefaultStringEncoding, context.CancellationToken)!;
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			source.Advance(reader.Consumed);
+
+			return true;
 		}
 
-		private static void ThrowFailedToDecodeAssemblyKeyToken()
+		private static bool TryDecodeBinaryTo(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, Span<byte> buffer, out int requestHint, Action<int, int, long> onLengthMismatch)
 		{
-			throw new SerializationException( "Failed to decode public key token component." );
+			var reader = new SequenceReader<byte>(source.Sequence);
+
+			var consumed = context.Decoder.DecodeBinary(ref reader, buffer, out requestHint, context.CancellationToken)!;
+			if (requestHint != 0)
+			{
+				return false;
+			}
+
+			if (consumed != buffer.Length)
+			{
+				onLengthMismatch(buffer.Length, consumed, source.Position);
+			}
+
+			source.Advance(reader.Consumed);
+
+			return true;
 		}
 
-		private static void CheckUnpackerForRuntimeTypeInfoDecoding( Unpacker unpacker )
+		private static bool? TryDecodeNullableBinaryTo(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, Span<byte> buffer, out int requestHint, Action<int, int, long> onLengthMismatch)
 		{
-			if ( !unpacker.IsArrayHeader )
+			var reader = new SequenceReader<byte>(source.Sequence);
+
+			var consumed = context.Decoder.DecodeNullableBinary(ref reader, buffer, out requestHint, context.CancellationToken)!;
+			if (requestHint != 0)
 			{
-				ThrowEncodedTypeIsNotInNonNillArray();
+				return false;
 			}
 
-			if ( unpacker.ItemsCount != 6 )
+			if (consumed != null && consumed.GetValueOrDefault() != buffer.Length)
 			{
-				ThrowEncodedTypeDoesNotHaveValidArrayItems();
+				onLengthMismatch(buffer.Length, consumed.GetValueOrDefault(), source.Position);
 			}
+
+			source.Advance(reader.Consumed);
+
+			return consumed == null ? default(bool?) : true;
 		}
 
-		private static void ThrowEncodedTypeIsNotInNonNillArray()
+		private static async ValueTask EnsureIteratorHasNextAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, CollectionItemIterator iterator, long initialPosition)
 		{
-			throw new SerializationException( "Type info must be non-nil array." );
+			while (true)
+			{
+				var ends = iterator.CollectionEnds(source.Sequence, out var requestHint);
+				if (requestHint == 0)
+				{
+					if (!ends)
+					{
+						return;
+					}
+
+					Throw.UnknownTypeEmbedding(initialPosition);
+				}
+
+				await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+			}
 		}
 
-		private static void ThrowEncodedTypeDoesNotHaveValidArrayItems()
+		private static async ValueTask EnsureIteratorEndsAsync(AsyncDeserializationOperationContext context, ReadOnlyStreamSequence source, CollectionItemIterator iterator, long initialPosition)
 		{
-			throw new SerializationException( "Components count of type info is not valid." );
+			while (true)
+			{
+				var ends = iterator.CollectionEnds(source.Sequence, out var requestHint);
+				if (requestHint == 0)
+				{
+					if (ends)
+					{
+						// OK.
+						return;
+					}
+
+					Throw.UnknownTypeEmbedding(initialPosition);
+				}
+				else
+				{
+					await source.FetchAsync(requestHint, context.CancellationToken).ConfigureAwait(false);
+				}
+			}
 		}
 
-		private static AssemblyName BuildAssemblyName( string assemblySimpleName, byte[] version, string culture, byte[] publicKeyToken )
+#endif // FEATURE_TAP
+
+		private static AssemblyName BuildAssemblyName(string assemblySimpleName, ReadOnlySpan<byte> version, string? culture, ReadOnlySpan<byte> publicKeyToken)
 		{
 #if !NETSTANDARD1_1 && !NETSTANDARD1_3
 			var assemblyName =
@@ -352,122 +887,53 @@ private static AssemblyName BuildAssemblyName( string assemblySimpleName, byte[]
 					Name = assemblySimpleName,
 					Version =
 						new Version(
-							BitConverter.ToInt32( version, 0 ),
-							BitConverter.ToInt32( version, 4 ),
-							BitConverter.ToInt32( version, 8 ),
-							BitConverter.ToInt32( version, 12 )
+							BinaryPrimitives.ReadInt32LittleEndian(version),
+							BinaryPrimitives.ReadInt32LittleEndian(version.Slice(4)),
+							BinaryPrimitives.ReadInt32LittleEndian(version.Slice(8)),
+							BinaryPrimitives.ReadInt32LittleEndian(version.Slice(12))
 						),
 					CultureInfo =
-						String.IsNullOrEmpty( culture )
-							? null
-#if !SILVERLIGHT
-							: CultureInfo.GetCultureInfo( culture ),
-#else
-							: new CultureInfo( culture ),
-#endif //  !SILVERLIGHT
+						String.IsNullOrEmpty(culture) ?
+							null :
+							CultureInfo.GetCultureInfo(culture),
 				};
-			assemblyName.SetPublicKeyToken( publicKeyToken );
+			if (!publicKeyToken.IsEmpty)
+			{
+				assemblyName.SetPublicKeyToken(publicKeyToken.ToArray());
+			}
+
 			return assemblyName;
 #else
 			return
-				new AssemblyName( 
+				new AssemblyName(
 					String.Format( 
 						CultureInfo.InvariantCulture, 
 						"{0},Version={1},Culture={2},PublicKeyToken={3}",
 						assemblySimpleName,
 						new Version(
-							BitConverter.ToInt32( version, 0 ),
-							BitConverter.ToInt32( version, 4 ),
-							BitConverter.ToInt32( version, 8 ),
-							BitConverter.ToInt32( version, 12 )
+							BinaryPrimitives.ReadInt32LittleEndian(version),
+							BinaryPrimitives.ReadInt32LittleEndian(version.Slice(4)),
+							BinaryPrimitives.ReadInt32LittleEndian(version.Slice(8)),
+							BinaryPrimitives.ReadInt32LittleEndian(version.Slice(12))
 						),
-						String.IsNullOrEmpty( culture ) ? "neutral" : culture,
-						( publicKeyToken == null || publicKeyToken.Length == 0 ) ? "null" : Binary.ToHexString( publicKeyToken, false )
+						String.IsNullOrEmpty(culture) ? "neutral" : culture,
+						publicKeyToken.IsEmpty ? "null" : Binary.ToHexString(publicKeyToken, false)
 					)
 				);
 #endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
 		}
 
-		private static string DecompressTypeName( string assemblySimpleName, string compressedTypeName )
-		{
-			return
-				compressedTypeName.StartsWith( Elipsis, StringComparison.Ordinal )
-					? assemblySimpleName + compressedTypeName
-					: compressedTypeName;
-		}
+		private static string DecompressTypeName(string assemblySimpleName, string compressedTypeName)
+			=> compressedTypeName.StartsWith(Elipsis, StringComparison.Ordinal) ?
+				assemblySimpleName + compressedTypeName :
+				compressedTypeName;
 
-		private static Type LoadDecodedType( AssemblyName assemblyName, string typeFullName )
-		{
-			return
-				Assembly.Load(
+		private static Type LoadDecodedType(AssemblyName assemblyName, string typeFullName)
+			=> Assembly.Load(
 					assemblyName
-#if SILVERLIGHT
-					.ToString()
-#endif // SILVERLIGHT
 				).GetType(
-					typeFullName
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
-					, throwOnError: true
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
-				);
-		}
-
-#if FEATURE_TAP
-
-		public static async Task<Type> DecodeRuntimeTypeInfoAsync( Unpacker unpacker, Func<PolymorphicTypeVerificationContext, bool> typeVerifier, CancellationToken cancellationToken )
-		{
-			CheckUnpackerForRuntimeTypeInfoDecoding( unpacker );
-
-			using ( var subTreeUnpacker = unpacker.ReadSubtree() )
-			{
-				var encodeType = await subTreeUnpacker.ReadByteAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !encodeType.Success )
-				{
-					ThrowFailedToDecodeEncodingType();
-				}
-
-				if ( encodeType.Value != ( byte )TypeInfoEncoding.RawCompressed )
-				{
-					ThrowUnknownEncodingType( encodeType.Value );
-				}
-
-				var compressedTypeName = await subTreeUnpacker.ReadStringAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !compressedTypeName.Success )
-				{
-					ThrowFailedToDecodeCompressedTypeName();
-				}
-
-				var assemblySimpleName = await subTreeUnpacker.ReadStringAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !assemblySimpleName.Success )
-				{
-					ThrowFailedToDecodeAssemblySimpleName();
-				}
-
-				var version = await subTreeUnpacker.ReadBinaryAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !version.Success )
-				{
-					ThrowFailedToDecodeAssemblyVersion();
-				}
-
-				var culture = await subTreeUnpacker.ReadStringAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !culture.Success )
-				{
-					ThrowFailedToDecodeAssemblyCulture();
-				}
-
-				var publicKeyToken = await subTreeUnpacker.ReadBinaryAsync( cancellationToken ).ConfigureAwait( false );
-				if ( !publicKeyToken.Success )
-				{
-					ThrowFailedToDecodeAssemblyKeyToken();
-				}
-
-				var assemblyName = BuildAssemblyName( assemblySimpleName.Value, version.Value, culture.Value, publicKeyToken.Value );
-				var typeFullName = DecompressTypeName( assemblyName.Name, compressedTypeName.Value );
-				RuntimeTypeVerifier.Verify( assemblyName, typeFullName, typeVerifier );
-				return LoadDecodedType( assemblyName, typeFullName );
-			}
-		}
-
-#endif // FEATURE_TAP
+					typeFullName,
+					throwOnError: true
+				)!;
 	}
 }
diff --git a/src/MsgPack/Serialization/PolymorphismSchema.Constructors.cs b/src/MsgPack/Serialization/PolymorphismSchema.Constructors.cs
index cce22f106..3a0003963 100644
--- a/src/MsgPack/Serialization/PolymorphismSchema.Constructors.cs
+++ b/src/MsgPack/Serialization/PolymorphismSchema.Constructors.cs
@@ -1,24 +1,6 @@
-#region -- License Terms --
-//  MessagePack for CLI
-// 
-//  Copyright (C) 2015-2016 FUJIWARA, Yusuke
-// 
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-// 
-//         http://www.apache.org/licenses/LICENSE-2.0
-// 
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
@@ -27,10 +9,10 @@
 
 namespace MsgPack.Serialization
 {
-	partial class PolymorphismSchema
+	public partial class PolymorphismSchema
 	{
-		private static readonly Dictionary<string, Type> EmptyMap = new Dictionary<string, Type>( 0 );
-		private static readonly PolymorphismSchema[] EmptyChildren = new PolymorphismSchema[ 0 ];
+		private static readonly Dictionary<string, Type> EmptyMap = new Dictionary<string, Type>(0);
+		private static readonly PolymorphismSchema[] EmptyChildren = new PolymorphismSchema[0];
 
 		// Internal only, for Default
 		private PolymorphismSchema()
@@ -39,12 +21,12 @@ private PolymorphismSchema()
 			this.PolymorphismType = PolymorphismType.None;
 			this.ChildrenType = PolymorphismSchemaChildrenType.None;
 #if !UNITY
-			this._codeTypeMapping = new ReadOnlyDictionary<string, Type>( EmptyMap );
-			this._children = new ReadOnlyCollection<PolymorphismSchema>( EmptyChildren );
+			this._codeTypeMapping = new ReadOnlyDictionary<string, Type>(EmptyMap);
+			this._children = new ReadOnlyCollection<PolymorphismSchema>(EmptyChildren);
 #else
 			// Work-around Unity type intiialization issue.
-			this._codeTypeMapping = new ReadOnlyDictionary<string, Type>( new Dictionary<string, Type>( 0 ) );
-			this._children = new ReadOnlyCollection<PolymorphismSchema>( new PolymorphismSchema[ 0 ] );
+			this._codeTypeMapping = new ReadOnlyDictionary<string, Type>(new Dictionary<string, Type>(0));
+			this._children = new ReadOnlyCollection<PolymorphismSchema>(new PolymorphismSchema[0]);
 #endif
 		}
 
@@ -52,55 +34,52 @@ private PolymorphismSchema()
 		private PolymorphismSchema(
 			Type targetType,
 			PolymorphismType polymorphismType,
-			Func<PolymorphicTypeVerificationContext, bool> typeVerifier,
+			Func<PolymorphicTypeVerificationContext, bool>? typeVerifier,
 			PolymorphismSchemaChildrenType childrenType,
 			params PolymorphismSchema[] childItemSchemaList
 		)
 			: this(
 				targetType,
 				polymorphismType,
-				new ReadOnlyDictionary<string, Type>( EmptyMap ),
+				new ReadOnlyDictionary<string, Type>(EmptyMap),
 				typeVerifier,
 				childrenType,
 				new ReadOnlyCollection<PolymorphismSchema>(
-					( childItemSchemaList ?? EmptyChildren ).Select( x => x ?? Default ).ToArray()
-				) 
-			) {}
+					(childItemSchemaList ?? EmptyChildren).Select(x => x ?? Default).ToArray()
+				)
+			)
+		{ }
 
 		private PolymorphismSchema(
 			Type targetType,
 			PolymorphismType polymorphismType,
 			IDictionary<string, Type> codeTypeMapping,
-			Func<PolymorphicTypeVerificationContext, bool> typeVerifier,
+			Func<PolymorphicTypeVerificationContext, bool>? typeVerifier,
 			PolymorphismSchemaChildrenType childrenType,
 			params PolymorphismSchema[] childItemSchemaList
 		)
 			: this(
 				targetType,
 				polymorphismType,
-				new ReadOnlyDictionary<string, Type>( codeTypeMapping ),
+				new ReadOnlyDictionary<string, Type>(codeTypeMapping),
 				typeVerifier,
 				childrenType,
 				new ReadOnlyCollection<PolymorphismSchema>(
-					( childItemSchemaList ?? EmptyChildren ).Select( x => x ?? Default ).ToArray()
+					(childItemSchemaList ?? EmptyChildren).Select(x => x ?? Default).ToArray()
 				)
-			) {}
+			)
+		{ }
 
 		private PolymorphismSchema(
 			Type targetType,
 			PolymorphismType polymorphismType,
 			ReadOnlyDictionary<string, Type> codeTypeMapping,
-			Func<PolymorphicTypeVerificationContext, bool> typeVerifier,
+			Func<PolymorphicTypeVerificationContext, bool>? typeVerifier,
 			PolymorphismSchemaChildrenType childrenType,
 			ReadOnlyCollection<PolymorphismSchema> childItemSchemaList
 		)
 		{
-			if ( targetType == null )
-			{
-				throw new ArgumentNullException( "targetType" );
-			}
-
-			this.TargetType = targetType;
+			this.TargetType = Ensure.NotNull(targetType);
 			this.PolymorphismType = polymorphismType;
 			this._codeTypeMapping = codeTypeMapping;
 			this.ChildrenType = childrenType;
@@ -116,10 +95,8 @@ ReadOnlyCollection<PolymorphismSchema> childItemSchemaList
 		/// <param name="targetType">The type of the serialization target.</param>
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for non-collection object which uses type embedding based polymorphism.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
-		public static PolymorphismSchema ForPolymorphicObject( Type targetType )
-		{
-			return new PolymorphismSchema( targetType, PolymorphismType.RuntimeType, DefaultTypeVerfiier, PolymorphismSchemaChildrenType.None );
-		}
+		public static PolymorphismSchema ForPolymorphicObject(Type targetType)
+			=> new PolymorphismSchema(targetType, PolymorphismType.RuntimeType, DefaultTypeVerfiier, PolymorphismSchemaChildrenType.None);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for non-collection object which uses type embedding based polymorphism.
@@ -128,10 +105,8 @@ public static PolymorphismSchema ForPolymorphicObject( Type targetType )
 		/// <param name="typeVerifier">The delegate which verifies loading type in runtime type polymorphism.</param>
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for non-collection object which uses type embedding based polymorphism.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
-		public static PolymorphismSchema ForPolymorphicObject( Type targetType, Func<PolymorphicTypeVerificationContext, bool> typeVerifier )
-		{
-			return new PolymorphismSchema( targetType, PolymorphismType.RuntimeType, typeVerifier, PolymorphismSchemaChildrenType.None );
-		}
+		public static PolymorphismSchema ForPolymorphicObject(Type targetType, Func<PolymorphicTypeVerificationContext, bool> typeVerifier)
+			=> new PolymorphismSchema(targetType, PolymorphismType.RuntimeType, typeVerifier, PolymorphismSchemaChildrenType.None);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for non-collection object which uses ext-type code mapping based polymorphism.
@@ -140,17 +115,14 @@ public static PolymorphismSchema ForPolymorphicObject( Type targetType, Func<Pol
 		/// <param name="codeTypeMapping">The code-type mapping which maps between ext-type codes and .NET <see cref="Type"/>s.</param>
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for non-collection object which uses ext-type code mapping based polymorphism.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
-		public static PolymorphismSchema ForPolymorphicObject( Type targetType, IDictionary<string, Type> codeTypeMapping )
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.KnownTypes,
-					codeTypeMapping,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.None
-				);
-		}
+		public static PolymorphismSchema ForPolymorphicObject(Type targetType, IDictionary<string, Type> codeTypeMapping)
+			=> new PolymorphismSchema(
+				targetType,
+				PolymorphismType.KnownTypes,
+				codeTypeMapping,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.None
+			);
 
 		// Collection items
 
@@ -161,17 +133,14 @@ public static PolymorphismSchema ForPolymorphicObject( Type targetType, IDiction
 		/// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses declared type or context specified concrete type.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
-		public static PolymorphismSchema ForContextSpecifiedCollection( Type targetType, PolymorphismSchema itemSchema )
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.None,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.CollectionItems,
-					itemSchema
-				);
-		}
+		public static PolymorphismSchema ForContextSpecifiedCollection(Type targetType, PolymorphismSchema itemSchema)
+			=> new PolymorphismSchema(
+				targetType,
+				PolymorphismType.None,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.CollectionItems,
+				itemSchema
+			);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.
@@ -180,17 +149,14 @@ public static PolymorphismSchema ForContextSpecifiedCollection( Type targetType,
 		/// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
-		public static PolymorphismSchema ForPolymorphicCollection( Type targetType, PolymorphismSchema itemSchema )
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.RuntimeType,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.CollectionItems,
-					itemSchema
-				);
-		}
+		public static PolymorphismSchema ForPolymorphicCollection(Type targetType, PolymorphismSchema itemSchema)
+			=> new PolymorphismSchema(
+				targetType,
+				PolymorphismType.RuntimeType,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.CollectionItems,
+				itemSchema
+			);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.
@@ -200,17 +166,14 @@ public static PolymorphismSchema ForPolymorphicCollection( Type targetType, Poly
 		/// <param name="typeVerifier">The delegate which verifies loading type in runtime type polymorphism.</param>
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
-		public static PolymorphismSchema ForPolymorphicCollection( Type targetType, PolymorphismSchema itemSchema, Func<PolymorphicTypeVerificationContext, bool> typeVerifier )
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.RuntimeType,
-					typeVerifier,
-					PolymorphismSchemaChildrenType.CollectionItems,
-					itemSchema
-				);
-		}
+		public static PolymorphismSchema ForPolymorphicCollection(Type targetType, PolymorphismSchema itemSchema, Func<PolymorphicTypeVerificationContext, bool> typeVerifier)
+			=> new PolymorphismSchema(
+				targetType,
+				PolymorphismType.RuntimeType,
+				typeVerifier,
+				PolymorphismSchemaChildrenType.CollectionItems,
+				itemSchema
+			);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses ext-type code mapping based polymorphism.
@@ -224,18 +187,14 @@ public static PolymorphismSchema ForPolymorphicCollection(
 			Type targetType,
 			IDictionary<string, Type> codeTypeMapping,
 			PolymorphismSchema itemSchema
-		)
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.KnownTypes,
-					codeTypeMapping,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.CollectionItems,
-					itemSchema
-				);
-		}
+		) => new PolymorphismSchema(
+				targetType,
+				PolymorphismType.KnownTypes,
+				codeTypeMapping,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.CollectionItems,
+				itemSchema
+			);
 
 		// Dictionary key/values
 
@@ -251,18 +210,14 @@ public static PolymorphismSchema ForContextSpecifiedDictionary(
 			Type targetType,
 			PolymorphismSchema keySchema,
 			PolymorphismSchema valueSchema
-		)
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.None,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.DictionaryKeyValues,
-					keySchema,
-					valueSchema
-				);
-		}
+		) => new PolymorphismSchema(
+				targetType,
+				PolymorphismType.None,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.DictionaryKeyValues,
+				keySchema,
+				valueSchema
+			);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses type embedding based polymorphism.
@@ -276,18 +231,14 @@ public static PolymorphismSchema ForPolymorphicDictionary(
 			Type targetType,
 			PolymorphismSchema keySchema,
 			PolymorphismSchema valueSchema
-		)
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.RuntimeType,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.DictionaryKeyValues,
-					keySchema,
-					valueSchema
-				);
-		}
+		) => new PolymorphismSchema(
+				targetType,
+				PolymorphismType.RuntimeType,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.DictionaryKeyValues,
+				keySchema,
+				valueSchema
+			);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses type embedding based polymorphism.
@@ -303,18 +254,14 @@ public static PolymorphismSchema ForPolymorphicDictionary(
 			PolymorphismSchema keySchema,
 			PolymorphismSchema valueSchema,
 			Func<PolymorphicTypeVerificationContext, bool> typeVerifier
-		)
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.RuntimeType,
-					typeVerifier,
-					PolymorphismSchemaChildrenType.DictionaryKeyValues,
-					keySchema,
-					valueSchema
-				);
-		}
+		) => new PolymorphismSchema(
+				targetType,
+				PolymorphismType.RuntimeType,
+				typeVerifier,
+				PolymorphismSchemaChildrenType.DictionaryKeyValues,
+				keySchema,
+				valueSchema
+			);
 
 		/// <summary>
 		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses ext-type code mapping based polymorphism.
@@ -330,21 +277,17 @@ public static PolymorphismSchema ForPolymorphicDictionary(
 			IDictionary<string, Type> codeTypeMapping,
 			PolymorphismSchema keySchema,
 			PolymorphismSchema valueSchema
-		)
-		{
-			return
-				new PolymorphismSchema(
-					targetType,
-					PolymorphismType.KnownTypes,
-					codeTypeMapping,
-					DefaultTypeVerfiier,
-					PolymorphismSchemaChildrenType.DictionaryKeyValues,
-					keySchema,
-					valueSchema
-				);
-		}
+		) => new PolymorphismSchema(
+				targetType,
+				PolymorphismType.KnownTypes,
+				codeTypeMapping,
+				DefaultTypeVerfiier,
+				PolymorphismSchemaChildrenType.DictionaryKeyValues,
+				keySchema,
+				valueSchema
+			);
 
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 		// Tuple items
 
 		/// <summary>
@@ -355,9 +298,9 @@ PolymorphismSchema valueSchema
 		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for <see cref="Tuple"/> object.</returns>
 		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
 		/// <exception cref="System.ArgumentException">A count of <paramref name="itemSchemaList"/> does not match for an arity of the tuple type specified as <paramref name="targetType"/>.</exception>
-		public static PolymorphismSchema ForPolymorphicTuple( Type targetType, PolymorphismSchema[] itemSchemaList )
+		public static PolymorphismSchema ForPolymorphicTuple(Type targetType, PolymorphismSchema[] itemSchemaList)
 		{
-			VerifyArity( targetType, itemSchemaList );
+			VerifyArity(targetType, itemSchemaList);
 			return
 				new PolymorphismSchema(
 					targetType,
@@ -368,29 +311,29 @@ public static PolymorphismSchema ForPolymorphicTuple( Type targetType, Polymorph
 				);
 		}
 
-		private static void VerifyArity( Type tupleType, ICollection<PolymorphismSchema> itemSchemaList )
+		private static void VerifyArity(Type tupleType, ICollection<PolymorphismSchema> itemSchemaList)
 		{
-			if ( itemSchemaList == null || itemSchemaList.Count == 0 )
+			if (itemSchemaList == null || itemSchemaList.Count == 0)
 			{
 				// OK
 				return;
 			}
 
-			if ( TupleItems.GetTupleItemTypes( tupleType ).Count != itemSchemaList.Count )
+			if (TupleItems.GetTupleItemTypes(tupleType).Count != itemSchemaList.Count)
 			{
-				throw new ArgumentException( "An arity of itemSchemaList does not match for an arity of the tuple.", "itemSchemaList" );
+				throw new ArgumentException("An arity of itemSchemaList does not match for an arity of the tuple.", "itemSchemaList");
 			}
 		}
 #endif // !NET35 && !UNITY
 
 		internal PolymorphismSchema FilterSelf()
 		{
-			if ( this == Default )
+			if (this == Default)
 			{
 				return this;
 			}
 
-			return new PolymorphismSchema( this.TargetType, PolymorphismType.None, this._codeTypeMapping, this.TypeVerifier, this.ChildrenType, this._children );
+			return new PolymorphismSchema(this.TargetType, PolymorphismType.None, this._codeTypeMapping, this.TypeVerifier, this.ChildrenType, this._children);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs b/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs
index 62da7a124..b84439847 100644
--- a/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs
+++ b/src/MsgPack/Serialization/PolymorphismSchema.Internals.cs
@@ -4,14 +4,7 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Diagnostics;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
-using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
@@ -21,7 +14,7 @@
 
 namespace MsgPack.Serialization
 {
-	partial class PolymorphismSchema
+	public partial class PolymorphismSchema
 	{
 		private static readonly Func<PolymorphicTypeVerificationContext, bool> DefaultTypeVerfiier = _ => true;
 
@@ -31,69 +24,68 @@ partial class PolymorphismSchema
 		public static PolymorphismSchema Default { get; } = new PolymorphismSchema();
 
 		/// <summary>
-		///		ForPolymorphicObject( Type targetType )
+		///		ForPolymorphicObject(Type targetType)
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicObjectTypeEmbeddingMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicObject", new[] { typeof(Type) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicObject), new[] { typeof(Type) })!;
 
 		/// <summary>
-		///		ForPolymorphicObject( Type targetType, IDictionary{byte, Type} codeTypeMapping )
+		///		ForPolymorphicObject(Type targetType, IDictionary{byte, Type} codeTypeMapping)
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicObjectCodeTypeMappingMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicObject", new[] { typeof(Type), typeof(IDictionary<string, Type>) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicObject), new[] { typeof(Type), typeof(IDictionary<string, Type>) })!;
 
 		/// <summary>
 		///		ForContextSpecifiedCollection( Type targetType, PolymorphismSchema itemsSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForContextSpecifiedCollectionMethod =
-			typeof(PolymorphismSchema).GetMethod("ForContextSpecifiedCollection", new[] { typeof(Type), typeof(PolymorphismSchema) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForContextSpecifiedCollection), new[] { typeof(Type), typeof(PolymorphismSchema) })!;
 
 		/// <summary>
 		///		ForPolymorphicCollection( Type targetType, PolymorphismSchema itemsSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicCollectionTypeEmbeddingMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicCollection", new[] { typeof(Type), typeof(PolymorphismSchema) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicCollection), new[] { typeof(Type), typeof(PolymorphismSchema) })!;
 
 		/// <summary>
 		///		ForPolymorphicCollection( Type targetType, IDictionary{byte, Type} codeTypeMapping, PolymorphismSchema itemsSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicCollectionCodeTypeMappingMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicCollection", new[] { typeof(Type), typeof(IDictionary<string, Type>), typeof(PolymorphismSchema) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicCollection), new[] { typeof(Type), typeof(IDictionary<string, Type>), typeof(PolymorphismSchema) })!;
 
 		/// <summary>
 		///		ForContextSpecifiedDictionary( Type targetType, PolymorphismSchema keysSchema, PolymorphismSchema valuesSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForContextSpecifiedDictionaryMethod =
-			typeof(PolymorphismSchema).GetMethod("ForContextSpecifiedDictionary", new[] { typeof(Type), typeof(PolymorphismSchema), typeof(PolymorphismSchema) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForContextSpecifiedDictionary), new[] { typeof(Type), typeof(PolymorphismSchema), typeof(PolymorphismSchema) })!;
 
 		/// <summary>
 		///		ForPolymorphicDictionary( Type targetType, PolymorphismSchema keysSchema, PolymorphismSchema valuesSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicDictionaryTypeEmbeddingMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicDictionary", new[] { typeof(Type), typeof(PolymorphismSchema), typeof(PolymorphismSchema) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicDictionary), new[] { typeof(Type), typeof(PolymorphismSchema), typeof(PolymorphismSchema) })!;
 
 		/// <summary>
 		///		ForPolymorphicDictionary( Type targetType, IDictionary{byte, Type} codeTypeMapping, PolymorphismSchema keysSchema, PolymorphismSchema valuesSchema )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicDictionaryCodeTypeMappingMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicDictionary", new[] { typeof(Type), typeof(IDictionary<string, Type>), typeof(PolymorphismSchema), typeof(PolymorphismSchema) });
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicDictionary), new[] { typeof(Type), typeof(IDictionary<string, Type>), typeof(PolymorphismSchema), typeof(PolymorphismSchema) })!;
 
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 		/// <summary>
 		///		ForPolymorphicTuple( Type targetType, PolymorphismSchema[] itemSchemaList )
 		/// </summary>
 		internal static readonly MethodInfo ForPolymorphicTupleMethod =
-			typeof(PolymorphismSchema).GetMethod("ForPolymorphicTuple", new[] { typeof(Type), typeof(PolymorphismSchema[]) });
-#endif // !NET35 && !UNITY
+			typeof(PolymorphismSchema).GetMethod(nameof(ForPolymorphicTuple), new[] { typeof(Type), typeof(PolymorphismSchema[]) })!;
+#endif // FEATURE_TUPLE
 
 		internal static readonly ConstructorInfo CodeTypeMapConstructor =
 			typeof(Dictionary<,>).MakeGenericType(typeof(string), typeof(Type))
-				.GetConstructor(new[] { typeof(int) });
+				.GetConstructor(new[] { typeof(int) })!;
 
 		internal static readonly MethodInfo AddToCodeTypeMapMethod =
 			typeof(Dictionary<,>).MakeGenericType(typeof(string), typeof(Type))
-				.GetMethod("Add", new[] { typeof(string), typeof(Type) });
-
+				.GetMethod("Add", new[] { typeof(string), typeof(Type) })!;
 
 		internal string DebugString
 		{
@@ -148,7 +140,7 @@ private void ToDebugString(StringBuilder buffer)
 
 					break;
 				}
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 				case PolymorphismSchemaChildrenType.TupleItems:
 				{
 					buffer.Append(", TupleItemsSchema:[");
@@ -176,42 +168,30 @@ private void ToDebugString(StringBuilder buffer)
 
 					break;
 				}
-#endif // !NET35 && !UNITY
+#endif // FEATURE_TUPLE
 			}
 
 			buffer.Append('}');
 		}
 
 		internal static PolymorphismSchema Create(
-			DiagnosticSource diag,
-			Type type,
-#if !UNITY
+			Type memberType,
 			SerializingMember? memberMayBeNull
-#else
-			SerializingMember memberMayBeNull
-#endif // !UNITY
-			)
+		)
 		{
-			if (type.GetIsValueType())
+			if (memberType.GetIsValueType())
 			{
-				diag.DefaultPolymorphicSchemaForValueType(
-					new
-					{
-						targetType =
-							memberMayBeNull == null ?
-#if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-							type :
-#else
-							type.GetTypeInfo() :
-#endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-#if !UNITY
-							memberMayBeNull.Value.Member,
-#else
-							memberMayBeNull.Member,
-#endif
-						schema = Default
-					}
-				);
+				if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.DefaultSchemaForValueType))
+				{
+					Diagnostic.PolymorphicTrace.DefaultSchemaForValueType(
+						new
+						{
+							targetType = memberType,
+							schema = Default
+						}
+					);
+				}
+
 				// Value types will never be polymorphic.
 				return Default;
 			}
@@ -220,43 +200,35 @@ SerializingMember memberMayBeNull
 			{
 				var schema =
 					CreateCore(
-						diag,
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-						type,
+						memberType,
 #else
 						type.GetTypeInfo(),
 #endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
 						Default
 					);
-				diag.PolymorphicSchemaCreatedForRootType(
-					new
-					{
-						targetType =
-#if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-							type,
-#else
-							type.GetTypeInfo(),
-#endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-						schema = schema
-					}
-				);
+				if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.SchemaCreatedForRootType))
+				{
+					Diagnostic.PolymorphicTrace.SchemaCreatedForRootType(
+						new
+						{
+							targetType = memberType,
+							schema
+						}
+					);
+				}
+
 				return schema;
 			}
 
-#if !UNITY
 			var member = memberMayBeNull.Value;
-#else
-			var member = memberMayBeNull;
-#endif // !UNITY
 
 			return
 				CreateCore(
-					diag,
 					member.Member,
 					CreateCore(
-						diag,
 #if !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
-						type,
+						memberType,
 #else
 						type.GetTypeInfo(),
 #endif // !NETFX_CORE && !NETSTANDARD1_1 && !NETSTANDARD1_3
@@ -265,7 +237,7 @@ SerializingMember memberMayBeNull
 				);
 		}
 
-		private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo member, PolymorphismSchema defaultSchema)
+		private static PolymorphismSchema CreateCore(MemberInfo member, PolymorphismSchema defaultSchema)
 		{
 			var table = TypeTable.Create(member, defaultSchema);
 
@@ -277,13 +249,17 @@ private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo m
 				{
 					if (!table.Member.Exists && !table.CollectionItem.Exists)
 					{
-						diag.DefaultPolymorphicSchemaForUnqualifiedCollectionMember(
-							new
-							{
-								targetMember = member,
-								schema = defaultSchema
-							}
-						);
+						if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.DefaultSchemaForUnqualifiedCollectionMember))
+						{
+							Diagnostic.PolymorphicTrace.DefaultSchemaForUnqualifiedCollectionMember(
+								new
+								{
+									targetMember = member,
+									schema = defaultSchema
+								}
+							);
+						}
+
 						return defaultSchema;
 					}
 
@@ -305,26 +281,35 @@ private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo m
 								PolymorphismSchemaChildrenType.None
 							)
 						);
-					diag.PolymorphicSchemaCreatedForCollectionMember(
-						new
-						{
-							targetMember = member,
-							schema = result
-						}
-					);
-					return result;
-				}
-				case CollectionKind.Map:
-				{
-					if (!table.Member.Exists && !table.DictionaryKey.Exists && !table.CollectionItem.Exists)
+
+					if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.SchemaCreatedForCollectionMember))
 					{
-						diag.DefaultPolymorphicSchemaForUnqualifiedDictionaryMember(
+						Diagnostic.PolymorphicTrace.SchemaCreatedForCollectionMember(
 							new
 							{
 								targetMember = member,
-								schema = defaultSchema
+								schema = result
 							}
 						);
+					}
+
+					return result;
+				}
+				case CollectionKind.Map:
+				{
+					if (!table.Member.Exists && !table.DictionaryKey.Exists && !table.CollectionItem.Exists)
+					{
+						if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.DefaultSchemaForUnqualifiedDictionaryMember))
+						{
+							Diagnostic.PolymorphicTrace.DefaultSchemaForUnqualifiedDictionaryMember(
+								new
+								{
+									targetMember = member,
+									schema = defaultSchema
+								}
+							);
+						}
+
 						return defaultSchema;
 					}
 
@@ -355,29 +340,37 @@ private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo m
 							)
 						);
 
-					diag.PolymorphicSchemaCreatedForDictionaryMember(
-						new
-						{
-							targetMember = member,
-							schema = result
-						}
-					);
+					if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.SchemaCreatedForDictionaryMember))
+					{
+						Diagnostic.PolymorphicTrace.SchemaCreatedForDictionaryMember(
+							new
+							{
+								targetMember = member,
+								schema = result
+							}
+						);
+					}
+
 					return result;
 				}
 				default:
 				{
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 					if (TupleItems.IsTuple(member.GetMemberValueType()))
 					{
 						if (table.TupleItems.Count == 0)
 						{
-							diag.DefaultPolymorphicSchemaForUnqualifiedTupleMember(
-								new
-								{
-									targetMember = member,
-									schema = defaultSchema
-								}
-							);
+							if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.DefaultSchemaForUnqualifiedTupleMember))
+							{
+								Diagnostic.PolymorphicTrace.DefaultSchemaForUnqualifiedTupleMember(
+									new
+									{
+										targetMember = member,
+										schema = defaultSchema
+									}
+								);
+							}
+
 							return defaultSchema;
 						}
 
@@ -402,27 +395,34 @@ private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo m
 								).ToArray()
 							);
 
-						diag.PolymorphicSchemaCreatedForTupleMember(
-							new
-							{
-								targetMember = member,
-								schema = result
-							}
-						);
-						return result;
-					}
-					else
-#endif // !NET35 && !UNITY
-					{
-						if (!table.Member.Exists)
+						if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.SchemaCreatedForTupleMember))
 						{
-							diag.DefaultPolymorphicSchemaForUnqualifiedObjectMember(
+							Diagnostic.PolymorphicTrace.SchemaCreatedForTupleMember(
 								new
 								{
 									targetMember = member,
-									schema = defaultSchema
+									schema = result
 								}
 							);
+						}
+
+						return result;
+					}
+					else
+#endif // FEATURE_TUPLE
+					{
+						if (!table.Member.Exists)
+						{
+							if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.DefaultSchemaForUnqualifiedObjectMember))
+							{
+								Diagnostic.PolymorphicTrace.DefaultSchemaForUnqualifiedObjectMember(
+									new
+									{
+										targetMember = member,
+										schema = defaultSchema
+									}
+								);
+							}
 							return defaultSchema;
 						}
 
@@ -434,13 +434,17 @@ private static PolymorphismSchema CreateCore(DiagnosticSource diag, MemberInfo m
 								table.Member.TypeVerifier,
 								PolymorphismSchemaChildrenType.None
 							);
-						diag.PolymorphicSchemaCreatedForObjectMember(
-							new
-							{
-								targetMember = member,
-								schema = result
-							}
-						);
+
+						if (Diagnostic.PolymorphicTrace.IsEnabled(Diagnostic.PolymorphicTrace.Keys.SchemaCreatedForObjectMember))
+						{
+							Diagnostic.PolymorphicTrace.SchemaCreatedForObjectMember(
+								new
+								{
+									targetMember = member,
+									schema = result
+								}
+							);
+						}
 						return result;
 					}
 				}
@@ -452,76 +456,67 @@ private struct TypeTable
 			public readonly TypeTableEntry Member;
 			public readonly TypeTableEntry CollectionItem;
 			public readonly TypeTableEntry DictionaryKey;
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 			public readonly IList<TypeTableEntry> TupleItems;
-#endif // !NET35 && !UNITY
+#endif // FEATURE_TUPLE
 
 			private TypeTable(
 				TypeTableEntry member,
 				TypeTableEntry collectionItem,
 				TypeTableEntry dictionaryKey
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 				, IList<TypeTableEntry> tupleItems
-#endif // !NET35 && !UNITY
+#endif // FEATURE_TUPLE
 			)
 			{
 				this.Member = member;
 				this.CollectionItem = collectionItem;
 				this.DictionaryKey = dictionaryKey;
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 				this.TupleItems = tupleItems;
-#endif // !NET35 && !UNITY
+#endif // FEATURE_TUPLE
 			}
 
 			public static TypeTable Create(MemberInfo member, PolymorphismSchema defaultSchema)
-			{
-				return
-					new TypeTable(
-						TypeTableEntry.Create(member, PolymorphismTarget.Member, defaultSchema),
-						TypeTableEntry.Create(member, PolymorphismTarget.CollectionItem, defaultSchema.TryGetItemSchema()),
-						TypeTableEntry.Create(member, PolymorphismTarget.DictionaryKey, defaultSchema.TryGetKeySchema())
-#if !NET35 && !UNITY
-						, TypeTableEntry.CreateTupleItems(member)
-#endif // !NET35 && !UNITY
-					);
-			}
-		}
+				=> new TypeTable(
+					TypeTableEntry.Create(member, PolymorphismTarget.Member, defaultSchema),
+					TypeTableEntry.Create(member, PolymorphismTarget.CollectionItem, defaultSchema.TryGetItemSchema()),
+					TypeTableEntry.Create(member, PolymorphismTarget.DictionaryKey, defaultSchema.TryGetKeySchema())
+#if FEATURE_TUPLE
+					, TypeTableEntry.CreateTupleItems(member)
+#endif // !FEATURE_TUPLE
+				);
+		} // TypeTable
 
 		private sealed class TypeTableEntry
 		{
-#if !NET35 && !UNITY
+#if FEATURE_TUPLE
 			private static readonly TypeTableEntry[] EmptyEntries = new TypeTableEntry[0];
-#endif // !NET35 && !UNITY
+#endif // FEATURE_TUPLE
 
 			private readonly Dictionary<string, Type> _knownTypeMapping = new Dictionary<string, Type>();
 
-			public IDictionary<string, Type> CodeTypeMapping { get { return this._knownTypeMapping; } }
+			public IDictionary<string, Type> CodeTypeMapping => this._knownTypeMapping;
 
 			private bool _useTypeEmbedding;
 
 			public PolymorphismType PolymorphismType
-			{
-				get
-				{
-					return
-						this._useTypeEmbedding
-							? PolymorphismType.RuntimeType
-							: this._knownTypeMapping.Count > 0
-								? PolymorphismType.KnownTypes
-								: PolymorphismType.None;
-				}
-			}
+				=> this._useTypeEmbedding ?
+					PolymorphismType.RuntimeType :
+					this._knownTypeMapping.Count > 0 ?
+						PolymorphismType.KnownTypes :
+						PolymorphismType.None;
 
-			public bool Exists { get { return this._useTypeEmbedding || this._knownTypeMapping.Count > 0; } }
+			public bool Exists => this._useTypeEmbedding || this._knownTypeMapping.Count > 0;
 
-			public Func<PolymorphicTypeVerificationContext, bool> TypeVerifier { get; private set; }
+			public Func<PolymorphicTypeVerificationContext, bool>? TypeVerifier { get; private set; }
 
 			private TypeTableEntry() { }
 
-			public static TypeTableEntry Create(MemberInfo member, PolymorphismTarget targetType, PolymorphismSchema defaultSchema)
+			public static TypeTableEntry Create(MemberInfo member, PolymorphismTarget targetType, PolymorphismSchema? defaultSchema)
 			{
 				var result = new TypeTableEntry();
-				var memberName = member.ToString();
+				var memberName = member.ToString()!;
 				foreach (
 					var attribute in
 						member.GetCustomAttributes(false)
@@ -559,7 +554,7 @@ var attribute in
 							.OrderBy(a => a.ItemNumber)
 				)
 				{
-					result[attribute.ItemNumber - 1].Interpret(attribute, member.ToString(), attribute.ItemNumber);
+					result[attribute.ItemNumber - 1].Interpret(attribute, member.ToString()!, attribute.ItemNumber);
 				}
 
 				return result;
@@ -568,33 +563,24 @@ var attribute in
 
 			private void Interpret(IPolymorphicHelperAttribute attribute, string memberName, int tupleItemNumber)
 			{
-				var asKnown = attribute as IPolymorphicKnownTypeAttribute;
-				if (asKnown != null)
+				if (attribute is IPolymorphicKnownTypeAttribute asKnown)
 				{
 					this.SetKnownType(attribute.Target, memberName, tupleItemNumber, asKnown.TypeCode, asKnown.BindingType);
 					return;
 				}
 
-#if DEBUG
-				Contract.Assert(attribute is IPolymorphicRuntimeTypeAttribute, attribute + " is IPolymorphicRuntimeTypeAttribute");
-#endif // DEBUG
+				var asRuntimeType = attribute as IPolymorphicRuntimeTypeAttribute;
+				Debug.Assert(asRuntimeType != null, attribute + " is IPolymorphicRuntimeTypeAttribute");
 				if (this._useTypeEmbedding)
 				{
-#if DEBUG
-					Contract.Assert(attribute.Target == PolymorphismTarget.TupleItem, attribute.Target + " == PolymorphismTarget.TupleItem");
-#endif // DEBUG
+					Debug.Assert(attribute.Target == PolymorphismTarget.TupleItem, attribute.Target + " == PolymorphismTarget.TupleItem");
+
 					throw new SerializationException(
-						String.Format(
-							CultureInfo.CurrentCulture,
-							"Cannot specify multiple '{0}' to #{1} item of tuple type member '{2}'.",
-							typeof(MessagePackRuntimeTupleItemTypeAttribute),
-							tupleItemNumber,
-							memberName
-						)
+						$"Cannot specify multiple '{typeof(MessagePackRuntimeTupleItemTypeAttribute)}' to #{tupleItemNumber} item of tuple type member '{memberName}'."
 					);
 				}
 
-				this.SetRuntimeType(attribute.Target, memberName, tupleItemNumber, GetVerifier(attribute as IPolymorphicRuntimeTypeAttribute));
+				this.SetRuntimeType(attribute.Target, memberName, tupleItemNumber, GetVerifier(asRuntimeType));
 			}
 
 			private void SetDefault(PolymorphismTarget target, string memberName, int tupleItemNumber, PolymorphismSchema defaultSchema)
@@ -646,7 +632,7 @@ private void SetKnownType(PolymorphismTarget target, string memberName, int tupl
 				}
 			}
 
-			private void SetRuntimeType(PolymorphismTarget target, string memberName, int tupleItemNumber, Func<PolymorphicTypeVerificationContext, bool> typeVerifier)
+			private void SetRuntimeType(PolymorphismTarget target, string memberName, int tupleItemNumber, Func<PolymorphicTypeVerificationContext, bool>? typeVerifier)
 			{
 				if (this._knownTypeMapping.Count > 0)
 				{
@@ -664,48 +650,19 @@ private static string GetCannotSpecifyKnownTypeAndRuntimeTypeErrorMessage(Polymo
 				{
 					case PolymorphismTarget.CollectionItem:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify '{0}' and '{1}' simultaneously to collection items of member '{2}' itself.",
-								typeof(MessagePackRuntimeCollectionItemTypeAttribute),
-								typeof(MessagePackKnownCollectionItemTypeAttribute),
-								memberName
-							);
+						return $"Cannot specify '{typeof(MessagePackRuntimeCollectionItemTypeAttribute)}' and '{typeof(MessagePackKnownCollectionItemTypeAttribute)}' simultaneously to collection items of member '{memberName}' itself.";
 					}
 					case PolymorphismTarget.DictionaryKey:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify '{0}' and '{1}' simultaneously to dictionary keys of member '{2}' itself.",
-								typeof(MessagePackRuntimeDictionaryKeyTypeAttribute),
-								typeof(MessagePackKnownDictionaryKeyTypeAttribute),
-								memberName
-							);
+						return $"Cannot specify '{typeof(MessagePackRuntimeDictionaryKeyTypeAttribute)}' and '{typeof(MessagePackKnownDictionaryKeyTypeAttribute)}' simultaneously to dictionary keys of member '{memberName}' itself.";
 					}
 					case PolymorphismTarget.TupleItem:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify '{0}' and '{1}' simultaneously to #{2} item of tuple type member '{3}' itself.",
-								typeof(MessagePackRuntimeTupleItemTypeAttribute),
-								typeof(MessagePackKnownTupleItemTypeAttribute),
-								tupleItemNumber,
-								memberName
-							);
+						return $"Cannot specify '{typeof(MessagePackRuntimeTupleItemTypeAttribute)}' and '{typeof(MessagePackKnownTupleItemTypeAttribute)}' simultaneously to #{tupleItemNumber} item of tuple type member '{memberName}' itself.";
 					}
 					default:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify '{0}' and '{1}' simultaneously to member '{2}' itself.",
-								typeof(MessagePackRuntimeTypeAttribute),
-								typeof(MessagePackKnownTypeAttribute),
-								memberName
-							);
+						return $"Cannot specify '{typeof(MessagePackRuntimeTypeAttribute)}' and '{typeof(MessagePackKnownTypeAttribute)}' simultaneously to member '{memberName}' itself.";
 					}
 				}
 			}
@@ -716,44 +673,19 @@ private static string GetCannotDuplicateKnownTypeCodeErrorMessage(PolymorphismTa
 				{
 					case PolymorphismTarget.CollectionItem:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify multiple types for ext-type code '{0}' for collection items of member '{1}'.",
-								StringEscape.ForDisplay(typeCode),
-								memberName
-							);
+						return $"Cannot specify multiple types for ext-type code '{StringEscape.ForDisplay(typeCode)}' for collection items of member '{memberName}'.";
 					}
 					case PolymorphismTarget.DictionaryKey:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify multiple types for ext-type code '{0}' for dictionary keys of member '{1}'.",
-								StringEscape.ForDisplay(typeCode),
-								memberName
-							);
+						return $"Cannot specify multiple types for ext-type code '{StringEscape.ForDisplay(typeCode)}' for dictionary keys of member '{memberName}'.";
 					}
 					case PolymorphismTarget.TupleItem:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify multiple types for ext-type code '{0}' for #{1} item of tuple type member '{2}'.",
-								StringEscape.ForDisplay(typeCode),
-								tupleItemNumber,
-								memberName
-							);
+						return $"Cannot specify multiple types for ext-type code '{StringEscape.ForDisplay(typeCode)}' for #{tupleItemNumber} item of tuple type member '{memberName}'.";
 					}
 					default:
 					{
-						return
-							String.Format(
-								CultureInfo.CurrentCulture,
-								"Cannot specify multiple types for ext-type code '{0}' for member '{1}'.",
-								StringEscape.ForDisplay(typeCode),
-								memberName
-							);
+						return $"Cannot specify multiple types for ext-type code '{StringEscape.ForDisplay(typeCode)}' for member '{memberName}'.";
 					}
 				}
 			}
@@ -775,16 +707,16 @@ private static Func<PolymorphicTypeVerificationContext, bool> GetVerifier(IPolym
 				var method = attribute.VerifierType.GetRuntimeMethods().SingleOrDefault(m => IsVerificationMethod(m, attribute.VerifierMethodName));
 				if (method == null)
 				{
-					throw new SerializationException(String.Format(CultureInfo.CurrentCulture, "A public static or instance method named '{0}' with single parameter typed PolymorphicTypeVerificationContext in type '{1}'.", attribute.VerifierMethodName, attribute.VerifierMethodName));
+					throw new SerializationException($"A public static or instance method named '{attribute.VerifierMethodName}' with single parameter typed PolymorphicTypeVerificationContext in type '{attribute.VerifierType}'.");
 				}
 
 				if (method.IsStatic)
 				{
-					return method.CreateDelegate(typeof(Func<PolymorphicTypeVerificationContext, bool>)) as Func<PolymorphicTypeVerificationContext, bool>;
+					return method.CreateDelegate<Func<PolymorphicTypeVerificationContext, bool>>();
 				}
 				else
 				{
-					return method.CreateDelegate(typeof(Func<PolymorphicTypeVerificationContext, bool>), Activator.CreateInstance(attribute.VerifierType)) as Func<PolymorphicTypeVerificationContext, bool>;
+					return (method.CreateDelegate(typeof(Func<PolymorphicTypeVerificationContext, bool>), Activator.CreateInstance(attribute.VerifierType)) as Func<PolymorphicTypeVerificationContext, bool>)!;
 				}
 			}
 
@@ -803,6 +735,6 @@ private static bool IsVerificationMethod(MethodInfo method, string name)
 				var parameters = method.GetParameters();
 				return parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(typeof(PolymorphicTypeVerificationContext));
 			}
-		}
+		} // TypeTableEntry
 	}
 }
diff --git a/src/MsgPack/Serialization/PolymorphismSchema.cs b/src/MsgPack/Serialization/PolymorphismSchema.cs
index 8fc7648a7..8255de6df 100644
--- a/src/MsgPack/Serialization/PolymorphismSchema.cs
+++ b/src/MsgPack/Serialization/PolymorphismSchema.cs
@@ -1,31 +1,14 @@
-#region -- License Terms --
-// 
-// MessagePack for CLI
-// 
-// Copyright (C) 2015-2016 FUJIWARA, Yusuke
-// 
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-// 
-//        http://www.apache.org/licenses/LICENSE-2.0
-// 
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-// 
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+#if !FEATURE_READ_ONLY_COLLECTION
+using System.Diagnostics.CodeAnalysis;
+#endif // !FEATURE_READ_ONLY_COLLECTION
 using System.Linq;
 
 namespace MsgPack.Serialization
@@ -42,7 +25,7 @@ public sealed partial class PolymorphismSchema
 		/// <value>
 		///		The type of the serialization target. This value can be <c>null</c>.
 		/// </value>
-		internal Type TargetType { get; private set; }
+		internal Type? TargetType { get; private set; }
 
 		/// <summary>
 		///		Gets the type of the polymorphism.
@@ -79,9 +62,7 @@ public sealed partial class PolymorphismSchema
 		///		The schema for child items of the serialization target collection/tuple.
 		/// </value>
 		internal IList<PolymorphismSchema> ChildSchemaList
-		{
-			get { return this._children; }
-		}
+			=> this._children;
 
 		/// <summary>
 		///		Gets the schema for collection items of the serialization target collection.
@@ -89,11 +70,11 @@ internal IList<PolymorphismSchema> ChildSchemaList
 		/// <value>
 		///		The schema for collection items of the serialization target collection.
 		/// </value>
-		internal PolymorphismSchema ItemSchema
+		internal PolymorphismSchema? ItemSchema
 		{
 			get
 			{
-				switch ( this.ChildrenType )
+				switch (this.ChildrenType)
 				{
 					case PolymorphismSchemaChildrenType.None:
 					{
@@ -105,7 +86,7 @@ internal PolymorphismSchema ItemSchema
 					}
 					case PolymorphismSchemaChildrenType.DictionaryKeyValues:
 					{
-						return this._children.Skip( 1 ).FirstOrDefault();
+						return this._children.Skip(1).FirstOrDefault();
 					}
 					default:
 					{
@@ -115,9 +96,9 @@ internal PolymorphismSchema ItemSchema
 			}
 		}
 
-		private PolymorphismSchema TryGetItemSchema()
+		private PolymorphismSchema? TryGetItemSchema()
 		{
-			switch ( this.ChildrenType )
+			switch (this.ChildrenType)
 			{
 				case PolymorphismSchemaChildrenType.CollectionItems:
 				{
@@ -125,7 +106,7 @@ private PolymorphismSchema TryGetItemSchema()
 				}
 				case PolymorphismSchemaChildrenType.DictionaryKeyValues:
 				{
-					return this._children.Skip( 1 ).FirstOrDefault();
+					return this._children.Skip(1).FirstOrDefault();
 				}
 				default:
 				{
@@ -140,11 +121,11 @@ private PolymorphismSchema TryGetItemSchema()
 		/// <value>
 		///		The schema for collection items of the serialization target collection.
 		/// </value>
-		internal PolymorphismSchema KeySchema
+		internal PolymorphismSchema? KeySchema
 		{
 			get
 			{
-				switch ( this.ChildrenType )
+				switch (this.ChildrenType)
 				{
 					case PolymorphismSchemaChildrenType.None:
 					{
@@ -162,9 +143,9 @@ internal PolymorphismSchema KeySchema
 			}
 		}
 
-		private PolymorphismSchema TryGetKeySchema()
+		private PolymorphismSchema? TryGetKeySchema()
 		{
-			if ( this.ChildrenType == PolymorphismSchemaChildrenType.DictionaryKeyValues )
+			if (this.ChildrenType == PolymorphismSchemaChildrenType.DictionaryKeyValues)
 			{
 				return this._children.FirstOrDefault();
 			}
@@ -174,100 +155,66 @@ private PolymorphismSchema TryGetKeySchema()
 			}
 		}
 
-#if NET35 || NET40 || SILVERLIGHT || UNITY || CORE_CLR || NETSTANDARD1_1
+#if !FEATURE_READ_ONLY_COLLECTION
 		private sealed class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+			where TKey : notnull
 		{
 			private readonly IDictionary<TKey, TValue> _underlying;
 
 			ICollection<TKey> IDictionary<TKey, TValue>.Keys
-			{
-				get { return this._underlying.Keys; }
-			}
+				=> this._underlying.Keys;
 
 			ICollection<TValue> IDictionary<TKey, TValue>.Values
-			{
-				get { return this._underlying.Values; }
-			}
+				=> this._underlying.Values;
 
-			TValue IDictionary<TKey, TValue>.this[ TKey key ]
+			TValue IDictionary<TKey, TValue>.this[TKey key]
 			{
-				get { return this._underlying[ key ]; }
-				set
-				{
-					throw new NotSupportedException();
-				}
+				get => this._underlying[key];
+				set => throw new NotSupportedException();
 			}
 
-			int ICollection<KeyValuePair<TKey, TValue>>.Count
-			{
-				get { return this._underlying.Count; }
-			}
+			int ICollection<KeyValuePair<TKey, TValue>>.Count => this._underlying.Count;
 
-			bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
-			{
-				get { return true; }
-			}
+			bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;
 
-			public ReadOnlyDictionary( IDictionary<TKey, TValue> underlying )
+			public ReadOnlyDictionary(IDictionary<TKey, TValue> underlying)
 			{
 				this._underlying = underlying;
 			}
 
-			bool IDictionary<TKey, TValue>.ContainsKey( TKey key )
-			{
-				return this._underlying.ContainsKey( key );
-			}
+			bool IDictionary<TKey, TValue>.ContainsKey(TKey key)
+				=> this._underlying.ContainsKey(key);
 
-			bool IDictionary<TKey, TValue>.TryGetValue( TKey key, out TValue value )
-			{
-				return this._underlying.TryGetValue( key, out value );
-			}
+			bool IDictionary<TKey, TValue>.TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
+				=> this._underlying.TryGetValue(key, out value);
 
-			bool ICollection<KeyValuePair<TKey, TValue>>.Contains( KeyValuePair<TKey, TValue> item )
-			{
-				return this._underlying.Contains( item );
-			}
+			bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
+				=> this._underlying.Contains(item);
 
-			void ICollection<KeyValuePair<TKey, TValue>>.CopyTo( KeyValuePair<TKey, TValue>[] array, int arrayIndex )
-			{
-				this._underlying.CopyTo( array, arrayIndex );
-			}
+			void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+				=> this._underlying.CopyTo(array, arrayIndex);
 
 			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
-			{
-				return this._underlying.GetEnumerator();
-			}
+				=> this._underlying.GetEnumerator();
 
 			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
-			{
-				return this._underlying.GetEnumerator();
-			}
+				=> this._underlying.GetEnumerator();
 
-			void IDictionary<TKey, TValue>.Add( TKey key, TValue value )
-			{
-				throw new NotSupportedException();
-			}
+			void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
+				=> throw new NotSupportedException();
 
-			bool IDictionary<TKey, TValue>.Remove( TKey key )
-			{
-				throw new NotSupportedException();
-			}
+			bool IDictionary<TKey, TValue>.Remove(TKey key)
+				=> throw new NotSupportedException();
 
-			void ICollection<KeyValuePair<TKey, TValue>>.Add( KeyValuePair<TKey, TValue> item )
-			{
-				throw new NotSupportedException();
-			}
+			void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
+				=> throw new NotSupportedException();
 
 			void ICollection<KeyValuePair<TKey, TValue>>.Clear()
-			{
-				throw new NotSupportedException();
-			}
+				=> throw new NotSupportedException();
 
-			bool ICollection<KeyValuePair<TKey, TValue>>.Remove( KeyValuePair<TKey, TValue> item )
-			{
-				throw new NotSupportedException();
-			}
+			bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
+				=> throw new NotSupportedException();
 		}
-#endif // NET35 || NET40 || SILVERLIGHT || UNITY
+#endif // !FEATURE_READ_ONLY_COLLECTION
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/PolymorphismSchemaChildrenType.cs b/src/MsgPack/Serialization/PolymorphismSchemaChildrenType.cs
index d74afa34b..fe9d818dc 100644
--- a/src/MsgPack/Serialization/PolymorphismSchemaChildrenType.cs
+++ b/src/MsgPack/Serialization/PolymorphismSchemaChildrenType.cs
@@ -1,20 +1,6 @@
-#region -- License Terms --
-//  MessagePack for CLI
-// 
-//  Copyright (C) 2015-2015 FUJIWARA, Yusuke
-// 
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-// 
-//         http://www.apache.org/licenses/LICENSE-2.0
-// 
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-#endregion -- License Terms --
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -47,4 +33,4 @@ internal enum PolymorphismSchemaChildrenType
 		TupleItems
 #endif // !NET35 && !UNITY
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/PolymorphismTarget.cs b/src/MsgPack/Serialization/PolymorphismTarget.cs
index 8946ff980..78ddad0dc 100644
--- a/src/MsgPack/Serialization/PolymorphismTarget.cs
+++ b/src/MsgPack/Serialization/PolymorphismTarget.cs
@@ -1,24 +1,6 @@
-#region -- License Terms --
-// 
-// MessagePack for CLI
-// 
-// Copyright (C) 2015 FUJIWARA, Yusuke
-// 
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-// 
-//        http://www.apache.org/licenses/LICENSE-2.0
-// 
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-// 
-#endregion -- License Terms --
-
-using System;
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 namespace MsgPack.Serialization
 {
@@ -29,7 +11,7 @@ internal enum PolymorphismTarget
 	{
 		/// <summary>
 		///		Applies to member type itself.
-		///		This option disables <see cref="SerializationContext.DefaultCollectionTypes"/> settings.
+		///		This option disables <see cref="SerializerProvider.DefaultCollectionTypes"/> settings.
 		/// </summary>
 		Member = 0,
 
@@ -51,4 +33,4 @@ internal enum PolymorphismTarget
 		/// </summary>
 		TupleItem = 3,
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs b/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs
index 322688145..c0bb74601 100644
--- a/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs
+++ b/src/MsgPack/Serialization/Reflection/ReflectionExtensions.cs
@@ -1,4 +1,4 @@
-#region -- License Terms --
+#region -- License Terms --
 //
 // NLiblet
 //
@@ -50,16 +50,16 @@ internal static class ReflectionExtensions
 		///   or if <paramref name="source"/> is a generic type parameter and <paramref name="target"/> represents one of the constraints of <paramref name="source"/>. 
 		///   <c>false</c> if none of these conditions are <c>true</c>, or if <paramref name="target"/> is <c>false</c>. 
 		/// </returns>
-		public static bool IsAssignableTo( this Type source, Type target )
+		public static bool IsAssignableTo(this Type source, Type target)
 		{
-			Contract.Assert( source != null, "source != null" );
+			Contract.Assert(source != null, "source != null");
 
-			if ( target == null )
+			if (target == null)
 			{
 				return false;
 			}
 
-			return target.IsAssignableFrom( source );
+			return target.IsAssignableFrom(source);
 		}
 
 #if DEBUG
@@ -68,71 +68,71 @@ public static bool IsAssignableTo( this Type source, Type target )
 		/// </summary>
 		/// <param name="source"><see cref="MethodAttributes"/>.</param>
 		/// <returns>IL friendly attributes string delimited by ASCII whitespace.</returns>
-		public static string ToILString( this MethodAttributes source )
+		public static string ToILString(this MethodAttributes source)
 		{
 			var result = new StringBuilder();
 
 			var memberAccess = source & MethodAttributes.MemberAccessMask;
-			switch ( memberAccess )
+			switch (memberAccess)
 			{
 				case MethodAttributes.PrivateScope:
 				{
-					result.Append( "privatescope" );
+					result.Append("privatescope");
 					break;
 				}
 				case MethodAttributes.Private:
 				{
-					result.Append( "private" );
+					result.Append("private");
 					break;
 				}
 				case MethodAttributes.FamANDAssem:
 				{
-					result.Append( "famandassem" );
+					result.Append("famandassem");
 					break;
 				}
 				case MethodAttributes.Assembly:
 				{
-					result.Append( "assembly" );
+					result.Append("assembly");
 					break;
 				}
 				case MethodAttributes.Family:
 				{
-					result.Append( "family" );
+					result.Append("family");
 					break;
 				}
 				case MethodAttributes.FamORAssem:
 				{
-					result.Append( "famorassem" );
+					result.Append("famorassem");
 					break;
 				}
 				case MethodAttributes.Public:
 				{
-					result.Append( "public" );
+					result.Append("public");
 					break;
 				}
 			}
-			AddString( result, source, MethodAttributes.HideBySig, "hidebysig" );
-			result.Append( ( source & MethodAttributes.VtableLayoutMask ) == 0 ? " reuseslot" : " newslot" );
-			AddString( result, source, MethodAttributes.SpecialName, "specialname" );
-			AddString( result, source, MethodAttributes.RTSpecialName, "rtspecialname" );
-			AddString( result, source, MethodAttributes.Static, "static" );
-			AddString( result, source, MethodAttributes.Abstract, "abstract" );
-			AddString( result, source, MethodAttributes.Virtual, "virtual" );
-			AddString( result, source, MethodAttributes.Final, "final" );
-			AddString( result, source, MethodAttributes.CheckAccessOnOverride, "checkaccessonoverride" );
-			AddString( result, source, MethodAttributes.HasSecurity, "hassecurity" );
-			AddString( result, source, MethodAttributes.RequireSecObject, "recsecobj" );
-			AddString( result, source, MethodAttributes.UnmanagedExport, "unmanagedexp" );
-			AddString( result, source, MethodAttributes.PinvokeImpl, "pinvokeimpl" );
+			AddString(result, source, MethodAttributes.HideBySig, "hidebysig");
+			result.Append((source & MethodAttributes.VtableLayoutMask) == 0 ? " reuseslot" : " newslot");
+			AddString(result, source, MethodAttributes.SpecialName, "specialname");
+			AddString(result, source, MethodAttributes.RTSpecialName, "rtspecialname");
+			AddString(result, source, MethodAttributes.Static, "static");
+			AddString(result, source, MethodAttributes.Abstract, "abstract");
+			AddString(result, source, MethodAttributes.Virtual, "virtual");
+			AddString(result, source, MethodAttributes.Final, "final");
+			AddString(result, source, MethodAttributes.CheckAccessOnOverride, "checkaccessonoverride");
+			AddString(result, source, MethodAttributes.HasSecurity, "hassecurity");
+			AddString(result, source, MethodAttributes.RequireSecObject, "recsecobj");
+			AddString(result, source, MethodAttributes.UnmanagedExport, "unmanagedexp");
+			AddString(result, source, MethodAttributes.PinvokeImpl, "pinvokeimpl");
 
 			return result.ToString();
 		}
 
-		private static void AddString( StringBuilder buffer, MethodAttributes source, MethodAttributes flag, string stringified )
+		private static void AddString(StringBuilder buffer, MethodAttributes source, MethodAttributes flag, string stringified)
 		{
-			if ( ( source & flag ) != 0 )
+			if ((source & flag) != 0)
 			{
-				buffer.Append( ' ' ).Append( stringified );
+				buffer.Append(' ').Append(stringified);
 			}
 		}
 
@@ -141,55 +141,55 @@ private static void AddString( StringBuilder buffer, MethodAttributes source, Me
 		/// </summary>
 		/// <param name="source"><see cref="CallingConventions"/>.</param>
 		/// <returns>IL friendly attributes string delimited by ASCII whitespace.</returns>
-		public static string ToILString( this CallingConventions source )
+		public static string ToILString(this CallingConventions source)
 		{
 			var result = new StringBuilder();
 
-			if ( ( source & CallingConventions.HasThis ) != 0 )
+			if ((source & CallingConventions.HasThis) != 0)
 			{
-				result.Append( "instance" );
+				result.Append("instance");
 			}
 
-			if ( ( source & CallingConventions.ExplicitThis ) != 0 )
+			if ((source & CallingConventions.ExplicitThis) != 0)
 			{
-				if ( result.Length > 0 )
+				if (result.Length > 0)
 				{
-					result.Append( ' ' );
+					result.Append(' ');
 				}
-	
-				result.Append( "explicit" );
+
+				result.Append("explicit");
 			}
 
-			switch ( (source & CallingConventions.Any) )
+			switch ((source & CallingConventions.Any))
 			{
 				case CallingConventions.Standard:
 				{
-					if ( result.Length > 0 )
+					if (result.Length > 0)
 					{
-						result.Append( ' ' );
+						result.Append(' ');
 					}
 
-					result.Append( "standard" );
+					result.Append("standard");
 					break;
 				}
 				case CallingConventions.VarArgs:
 				{
-					if ( result.Length > 0 )
+					if (result.Length > 0)
 					{
-						result.Append( ' ' );
+						result.Append(' ');
 					}
 
-					result.Append( "vararg" );
+					result.Append("vararg");
 					break;
 				}
 				case CallingConventions.Any:
 				{
-					if ( result.Length > 0 )
+					if (result.Length > 0)
 					{
-						result.Append( ' ' );
+						result.Append(' ');
 					}
 
-					result.Append( "any" );
+					result.Append("any");
 					break;
 				}
 			}
@@ -202,60 +202,60 @@ public static string ToILString( this CallingConventions source )
 		/// </summary>
 		/// <param name="source"><see cref="CallingConventions"/>.</param>
 		/// <returns>IL friendly attributes string delimited by ASCII whitespace.</returns>
-		public static string ToILString( this MethodImplAttributes source )
+		public static string ToILString(this MethodImplAttributes source)
 		{
 			var result = new StringBuilder();
 
 			// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
 			var codeType = source & MethodImplAttributes.CodeTypeMask;
-			switch ( codeType )
+			switch (codeType)
 			{
 				case MethodImplAttributes.IL:
 				{
-					result.Append( "cil" );
+					result.Append("cil");
 					break;
 				}
 				case MethodImplAttributes.Native:
 				{
-					result.Append( "native" );
+					result.Append("native");
 					break;
 				}
 				case MethodImplAttributes.OPTIL:
 				{
-					result.Append( "optil" );
+					result.Append("optil");
 					break;
 				}
 				case MethodImplAttributes.Runtime:
 				{
-					result.Append( "runtime" );
+					result.Append("runtime");
 					break;
 				}
 			}
 
 			// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
-			result.Append( ( source & MethodImplAttributes.ManagedMask ) == 0 ? " managed" : " unmanaged" );
+			result.Append((source & MethodImplAttributes.ManagedMask) == 0 ? " managed" : " unmanaged");
 
-			AddString( result, source, MethodImplAttributes.PreserveSig, "preservesig" );
-			AddString( result, source, MethodImplAttributes.ForwardRef, "forwardref" );
-			AddString( result, source, MethodImplAttributes.InternalCall, "internalcall" );
-			AddString( result, source, MethodImplAttributes.Synchronized, "synchronized" );
-			AddString( result, source, MethodImplAttributes.NoInlining, "noinlining" );
+			AddString(result, source, MethodImplAttributes.PreserveSig, "preservesig");
+			AddString(result, source, MethodImplAttributes.ForwardRef, "forwardref");
+			AddString(result, source, MethodImplAttributes.InternalCall, "internalcall");
+			AddString(result, source, MethodImplAttributes.Synchronized, "synchronized");
+			AddString(result, source, MethodImplAttributes.NoInlining, "noinlining");
 #if !UNITY
-			AddString( result, source, MethodImplAttributes.NoOptimization, "nooptimization" );
+			AddString(result, source, MethodImplAttributes.NoOptimization, "nooptimization");
 #if !NET35 && !NET40
-			AddString( result, source, MethodImplAttributes.AggressiveInlining, "aggressiveinlining" );
+			AddString(result, source, MethodImplAttributes.AggressiveInlining, "aggressiveinlining");
 #endif // !NET35 && !NET40
 #endif // !UNITY
 
 			return result.ToString();
 		}
 
-		private static void AddString( StringBuilder buffer, MethodImplAttributes source, MethodImplAttributes flag, string stringified )
+		private static void AddString(StringBuilder buffer, MethodImplAttributes source, MethodImplAttributes flag, string stringified)
 		{
 			// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
-			if ( ( source & flag ) != 0 )
+			if ((source & flag) != 0)
 			{
-				buffer.Append( ' ' ).Append( stringified );
+				buffer.Append(' ').Append(stringified);
 			}
 		}
 #endif // DEBUG
diff --git a/src/MsgPack/Serialization/ReflectionExtensions.InvokePreservingExtension.cs b/src/MsgPack/Serialization/ReflectionExtensions.InvokePreservingExtension.cs
index f39bfdc27..1707fcd64 100644
--- a/src/MsgPack/Serialization/ReflectionExtensions.InvokePreservingExtension.cs
+++ b/src/MsgPack/Serialization/ReflectionExtensions.InvokePreservingExtension.cs
@@ -1,132 +1,131 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Diagnostics;
 using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using MsgPack.Internal;
 
 namespace MsgPack.Serialization
 {
-	partial class ReflectionExtensions
+	internal partial class ReflectionExtensions
 	{
-		public static object InvokePreservingExceptionType( this ConstructorInfo source, params object[] parameters )
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static T InvokePreservingExceptionType<T>(this ConstructorInfo source, params object?[] parameters)
+			=> (T)InvokePreservingExceptionType(source, parameters);
+
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static object InvokePreservingExceptionType(this ConstructorInfo source, params object?[] parameters)
 		{
+#if FEATURE_DO_NOT_WRAP_EXCEPTIONS
+			return source.Invoke(BindingFlags.DoNotWrapExceptions, binder: null, parameters, culture: null);
+#else
 			try
 			{
-				return source.Invoke( parameters );
+				return source.Invoke(parameters);
 			}
-			catch ( TargetInvocationException ex )
+			catch (TargetInvocationException ex)
 			{
-				var rethrowing = HoistUpInnerException( ex );
-				if ( rethrowing == null )
-				{
-					// ctor.Invoke threw exception, so rethrow original TIE.
-					throw;
-				}
-				else
-				{
-					throw rethrowing;
-				}
+				HandleTargetInvocationException(ex);
+				throw; // failed to hoist-up, never reaches except .NET Framework 3.5
 			}
+#endif // FEATURE_DO_NOT_WRAP_EXCEPTIONS
 		}
 
-		public static object InvokePreservingExceptionType( this MethodInfo source, object instance, params object[] parameters )
+		public static object? InvokePreservingExceptionType(this MethodInfo source, object instance, params object[] parameters)
 		{
+#if FEATURE_DO_NOT_WRAP_EXCEPTIONS
+			return source.Invoke(instance, BindingFlags.DoNotWrapExceptions, binder: null, parameters, culture: null);
+#else
 			try
 			{
-				return source.Invoke( instance, parameters );
+				return source.Invoke(instance, parameters);
 			}
-			catch ( TargetInvocationException ex )
+			catch (TargetInvocationException ex)
 			{
-				var rethrowing = HoistUpInnerException( ex );
-				if ( rethrowing == null )
-				{
-					// ctor.Invoke threw exception, so rethrow original TIE.
-					throw;
-				}
-				else
-				{
-					throw rethrowing;
-				}
+				HandleTargetInvocationException(ex);
+				throw; // failed to hoist-up, never reaches except .NET Framework 3.5
 			}
+#endif // FEATURE_DO_NOT_WRAP_EXCEPTIONS
 		}
 
-		public static T CreateInstancePreservingExceptionType<T>( Type instanceType, params object[] constructorParameters )
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		public static T CreateInstancePreservingExceptionType<T>(this Type instanceType, params object?[] constructorParameters)
+			=> (T)CreateInstancePreservingExceptionType(instanceType, constructorParameters);
+
+		public static object CreateInstancePreservingExceptionType(this Type type, params object?[] constructorParameters)
 		{
-			return ( T ) CreateInstancePreservingExceptionType( instanceType, constructorParameters );
+#if FEATURE_DO_NOT_WRAP_EXCEPTIONS
+			return Activator.CreateInstance(type, BindingFlags.DoNotWrapExceptions, binder: null, constructorParameters, culture: null)!;
+#else
+			try
+			{
+				return Activator.CreateInstance(type, constructorParameters)!;
+			}
+			catch (TargetInvocationException ex)
+			{
+				HandleTargetInvocationException(ex);
+				throw; // failed to hoist-up, never reaches except .NET Framework 3.5
+			}
+#endif // FEATURE_DO_NOT_WRAP_EXCEPTIONS
 		}
 
-		public static object CreateInstancePreservingExceptionType( Type type, params object[] constructorParameters )
+		[MethodImpl(MethodImplOptionsShim.AggressiveInlining)]
+		private static void HandleTargetInvocationException(TargetInvocationException ex)
 		{
-			try
+#if FEATURE_EXCEPTION_DISPATCH_INFO
+			ExceptionDispatchInfo.Capture(ex).Throw();
+#else
+			var rethrowing = HoistUpInnerException(ex);
+			if (rethrowing == null)
 			{
-				return Activator.CreateInstance( type, constructorParameters );
+				// ctor.Invoke threw exception, so rethrow original TIE.
+				return;
 			}
-			catch ( TargetInvocationException ex )
+			else
 			{
-				var rethrowing = HoistUpInnerException( ex );
-				if ( rethrowing == null )
-				{
-					// ctor.Invoke threw exception, so rethrow original TIE.
-					throw;
-				}
-				else
-				{
-					throw rethrowing;
-				}
+				throw rethrowing;
 			}
+#endif // FEATURE_EXCEPTION_DISPATCH_INFO
 		}
 
-		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method should swallow exception in restoring inner exception of TargetInvocationException." )]
-		private static Exception HoistUpInnerException( TargetInvocationException targetInvocationException )
+#if !FEATURE_EXCEPTION_DISPATCH_INFO
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method should swallow exception in restoring inner exception of TargetInvocationException.")]
+		private static Exception? HoistUpInnerException(TargetInvocationException targetInvocationException)
 		{
-			if ( targetInvocationException.InnerException == null )
+			if (targetInvocationException.InnerException == null)
 			{
 				return null;
 			}
 
-			var ctor = targetInvocationException.InnerException.GetType().GetConstructor( ExceptionConstructorWithInnerParameterTypes );
-			if ( ctor == null )
+			var innerExceptionType = targetInvocationException.InnerException.GetType();
+			var ctor = innerExceptionType.GetConstructor(ExceptionConstructorWithInnerParameterTypes);
+			if (ctor == null)
 			{
+				Diagnostic.General.HoistUpInnerExceptionFailed(new { innerExceptionType });
 				return null;
 			}
 
 			try
 			{
-				return ctor.Invoke( new object[] { targetInvocationException.InnerException.Message, targetInvocationException } ) as Exception;
+				return (ctor.Invoke(new object[] { targetInvocationException.InnerException.Message, targetInvocationException }) as Exception);
 			}
-#if !UNITY || MSGPACK_UNITY_FULL
-			catch ( Exception ex )
-#else
-			catch ( Exception )
-#endif // !UNITY || MSGPACK_UNITY_FULL
+			catch (Exception ex)
 			{
-#if !UNITY || MSGPACK_UNITY_FULL
-				Debug.WriteLine( "HoistUpInnerException:" + ex );
-#endif // !UNITY || MSGPACK_UNITY_FULL
+				Diagnostic.General.HoistUpInnerExceptionFailed(new { innerExceptionType, instantiationError = ex });
 				return null;
 			}
 		}
+#endif // FEATURE_EXCEPTION_DISPATCH_INFO
+
+		public static ConstructorInfo GetRequiredConstructor(this Type type, params Type[] types)
+		{
+			var result = type.GetConstructor(types);
+			Debug.Assert(result != null, $"public {type}({String.Join(", ", types as object[])}) not found");
+			return result;
+		}
 	}
 }
diff --git a/src/MsgPack/Serialization/ReflectionExtensions.cs b/src/MsgPack/Serialization/ReflectionExtensions.cs
index f4d671b1c..d1d7cd182 100644
--- a/src/MsgPack/Serialization/ReflectionExtensions.cs
+++ b/src/MsgPack/Serialization/ReflectionExtensions.cs
@@ -3,23 +3,13 @@
 // See the LICENSE in the project root for more information.
 
 using System;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
 
 namespace MsgPack.Serialization
 {
-#if UNITY && DEBUG
-	public
-#else
-	internal
-#endif
-	static partial class ReflectionExtensions
+	internal static partial class ReflectionExtensions
 	{
 		private const string NullableAttributeTypeName = "System.CompilerServices.NullableAttribute";
 		private const string NullableContextAttributeTypeName = "System.CompilerServices.NullableContextAttribute";
@@ -102,12 +92,11 @@ public static Type GetMemberValueType(this MemberInfo source)
 				return asType;
 			}
 #else
-#if DEBUG
-			Contract.Assert( typeof( MemberInfo ).IsAssignableFrom( typeof( Type ) ), "Type is assginable to MemberInfo on this platform, so should not step in this line." );
-			Contract.Assert( typeof( Type ).IsAssignableFrom( typeof( TypeInfo ) ), "TypeInfo is assginable to Type on this platform, so should not step in this line." );
-#endif // DEBUG
+			Debug.Assert(typeof(MemberInfo).IsAssignableFrom(typeof(Type)), "Type is assginable to MemberInfo on this platform, so should not step in this line.");
+			Debug.Assert(typeof(Type).IsAssignableFrom(typeof(TypeInfo)), "TypeInfo is assginable to Type on this platform, so should not step in this line.");
+
 			var asTypeInfo = source as TypeInfo;
-			if ( asTypeInfo != null )
+			if (asTypeInfo != null)
 			{
 				// Nested type.
 				return asTypeInfo.AsType();
@@ -119,10 +108,10 @@ public static Type GetMemberValueType(this MemberInfo source)
 
 			if (asProperty == null && asField == null)
 			{
-				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "'{0}'({1}) is not field nor property.", source, source.GetType()));
+				throw new InvalidOperationException($"'{source}'({source.GetType()}) is not field nor property.");
 			}
 
-			return asProperty != null ? asProperty.PropertyType : asField.FieldType;
+			return asProperty != null ? asProperty.PropertyType : asField!.FieldType;
 		}
 	}
 }
diff --git a/src/MsgPack/Serialization/SerializationTarget.cs b/src/MsgPack/Serialization/SerializationTarget.cs
index 20a9e77bd..5bc4b8850 100644
--- a/src/MsgPack/Serialization/SerializationTarget.cs
+++ b/src/MsgPack/Serialization/SerializationTarget.cs
@@ -7,6 +7,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 #warning TODO: Implement generator and reflection with this type!
 #warning TODO: Separate factory method from this file for maintenancibility.
@@ -16,7 +17,7 @@ namespace MsgPack.Serialization
 	/// <summary>
 	///		Implements serialization target member extraction logics.
 	/// </summary>
-	internal readonly struct SerializationTarget
+	internal readonly partial struct SerializationTarget
 	{
 		// Type names to avoid user who doesn't embed "message pack assembly's attributes" in their code directly.
 		private static readonly string MessagePackMemberAttributeTypeName = typeof(MessagePackMemberAttribute).FullName!;
@@ -62,64 +63,17 @@ public SerializerCapabilities GetCapabilities()
 								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize | SerializerCapabilities.DeserializeTo)
 					) :
 					(
-						!this.CanDeserialize?
+						!this.CanDeserialize ?
 							SerializerCapabilities.Serialize :
 							this.Type.GetIsValueType() ?
 								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize) :
 								(SerializerCapabilities.Serialize | SerializerCapabilities.Deserialize | SerializerCapabilities.DeserializeTo)
 					);
 
-		private static string?[]? FindCorrespondentMemberNames(IReadOnlyList<SerializingMember> members, ConstructorInfo? constructor)
-		{
-			if (constructor == null)
-			{
-				return null;
-			}
-
-			Debug.Assert(!members.Any(m => m.Member == null), "members contains Tuple item.");
-
-			var constructorParameters = constructor.GetParameters();
-			return
-					constructorParameters.GroupJoin(
-						members,
-						p => new KeyValuePair<string, Type>(p.Name!, p.ParameterType),
-						m => new KeyValuePair<string, Type>(m.Contract.Name, m.Member!.GetMemberValueType()),
-						(p, ms) => DetermineCorrespondentMemberName(p, ms),
-						MemberConstructorParameterEqualityComparer.Instance
-					).ToArray();
-		}
-
-		private static string? DetermineCorrespondentMemberName(ParameterInfo parameterInfo, IEnumerable<SerializingMember> members)
-		{
-			var membersArray = members.ToArray();
-			switch (membersArray.Length)
-			{
-				case 0:
-				{
-					return null;
-				}
-				case 1:
-				{
-					return membersArray[0].MemberName;
-				}
-				default:
-				{
-					ThrowAmbigiousMatchException(parameterInfo, membersArray);
-					// never
-					return default!;
-				}
-			}
-		}
-
-		private static void ThrowAmbigiousMatchException(ParameterInfo parameterInfo, ICollection<SerializingMember> members) =>
-			throw new AmbiguousMatchException(
-				$"There are multiple candiates for corresponding member for parameter '{parameterInfo}' of constructor. [{String.Join(", ", members.Select(x => x.ToString()))}]"
-			);
-
 		public string? GetCorrespondentMemberName(int constructorParameterIndex)
 			=> this._correspondentMemberNames?[constructorParameterIndex];
 
-		public static void VerifyType(Type targetType)
+		private static void VerifyType(Type targetType)
 		{
 			if (targetType.GetIsInterface() || targetType.GetIsAbstract())
 			{
@@ -127,37 +81,54 @@ public static void VerifyType(Type targetType)
 			}
 		}
 
-		public static void VerifyCanSerializeTargetType(SerializerGenerationOptions options, Type targetType)
+		private static void VerifyCanSerializeTargetType(ISerializerGenerationOptions options, Type targetType)
 		{
-			if (options.DisablesPrivilegedAccess && !targetType.GetIsPublic() && !targetType.GetIsNestedPublic() && !ThisAssembly.Equals(targetType.GetAssembly()))
+			VerifyType(targetType);
+
+			if (options.BindingOptions.IsPrivilegedAccessDisabled && !targetType.GetIsPublic() && !targetType.GetIsNestedPublic() && !ThisAssembly.Equals(targetType.GetAssembly()))
 			{
 				Throw.CannotSerializeNonPublicTypeUnlessPrivledgedAccessEnabled(targetType);
 			}
 		}
 
-		public static SerializationTarget Prepare(DiagnosticListener diag, SerializerGenerationOptions options, Type targetType)
+		public static SerializationTarget Prepare(ISerializerGenerationOptions options, Type targetType)
 		{
 			VerifyCanSerializeTargetType(options, targetType);
 
-			var memberIgnoreList = options.IgnoringMembers.TryGetValue(targetType, out var ignoringMembers) ? ignoringMembers : Enumerable.Empty<string>();
-			var getters = GetTargetMembers(targetType, options)
+			var memberIgnoreList = options.BindingOptions.GetIgnoringMembers(targetType);
+
+			var deserializationConstructor = FindDeserializationConstructor(options, targetType, out var constructorKind);
+			var correspondentParameterMapping = new ConstructorParameterMapping(deserializationConstructor?.GetParameters() ?? Array.Empty<ParameterInfo>());
+
+			var getters = GetTargetMembers(targetType, (n, t) => correspondentParameterMapping.GetMappedParameterName(n, t), options, AreInternalsVisibleTo(targetType, options))
 						  .Where(getter => !memberIgnoreList.Contains(getter.MemberName, StringComparer.Ordinal))
 						  .OrderBy(entry => entry.Contract.Id)
 						  .ToArray();
 
-			if (getters.Length == 0 && !options.SerializableAnywayInterfaceDetector(targetType, options))
+			if (getters.Length == 0 && !options.CompatibilityOptions.SerializableInterfaceDetectors.Any(d => d(targetType, options)))
 			{
 				Throw.IsNotSerializableAnyway(targetType);
 			}
 
-			var memberCandidates = getters.Where(entry => CheckTargetEligibility(options, entry.Member!)).ToArray();
+			var memberCandidates = getters.Where(entry => entry.GetterAccessStrategy != MemberAccessStrategy.Skip).ToArray();
+
+			// NEW SPEC Draft
+			// 1. If it is "unbalanced" between getters and setters, skip unsettables.
+			// 2. If there is an explicit constructor, then use it. If multiple, use .ctor() for backward compatibility [should be error, needs switch]
+			// 3. If there is an parameterful consctructor, then use it.
+			// 4. Use default consctructor.
+			// 5. Deserialize rest members via setters. This is backward-compatible behavior.
+
+#warning If there are any settable members, ctor is ignored in v1??? We can use both of ctor and setters...
+			// Needs verification::
+			// 1. .ctor -> setters
+			// 2. .ctor -> IUnpackable
+			// 3. .ctor -> both parameters and setter -- should be once, and the change is backward compatible.
 
 			if (memberCandidates.Length == 0 && !options.AllowsAsymmetricSerializer)
 			{
-				ConstructorKind constructorKind;
-				var deserializationConstructor = FindDeserializationConstructor(diag, options, targetType, out constructorKind);
-				var complementedMembers = ComplementMembers(getters, options, targetType);
-				var correspondingMemberNames = FindCorrespondentMemberNames(complementedMembers, deserializationConstructor);
+				var complementedMembers = ComplementMembers(getters, options.CompatibilityOptions, targetType);
+				var correspondingMemberNames = correspondentParameterMapping.GetCorrespondentMemberNames();
 				return
 					new SerializationTarget(
 						targetType,
@@ -165,20 +136,18 @@ public static SerializationTarget Prepare(DiagnosticListener diag, SerializerGen
 						complementedMembers,
 						deserializationConstructor,
 						correspondingMemberNames,
-						DetermineCanDeserialize(diag, constructorKind, options, targetType, correspondingMemberNames, allowDefault: false)
+						DetermineCanDeserialize(constructorKind, options, targetType, correspondingMemberNames, allowDefault: false)
 					);
 			}
 			else
 			{
 				bool? canDeserialize;
-				ConstructorKind constructorKind;
 
 				// Try to get default constructor.
 				var constructor = targetType.GetConstructor(ReflectionAbstractions.EmptyTypes);
 				if (constructor == null && !targetType.GetIsValueType())
 				{
 					// Try to get deserialization constructor.
-					var deserializationConstructor = FindDeserializationConstructor(diag, options, targetType, out constructorKind);
 					if (deserializationConstructor == null && !options.AllowsAsymmetricSerializer)
 					{
 						Throw.TargetDoesNotHavePublicDefaultConstructor(targetType);
@@ -227,10 +196,10 @@ public static SerializationTarget Prepare(DiagnosticListener diag, SerializerGen
 				else
 				{
 					// ID order.
-					members = ComplementMembers(memberCandidates, options, targetType);
+					members = ComplementMembers(memberCandidates, options.CompatibilityOptions, targetType);
 				}
 
-				var correspondingMemberNames = FindCorrespondentMemberNames(members, constructor);
+				var correspondingMemberNames = correspondentParameterMapping.GetCorrespondentMemberNames();
 				return
 					new SerializationTarget(
 						targetType,
@@ -238,69 +207,134 @@ public static SerializationTarget Prepare(DiagnosticListener diag, SerializerGen
 						members,
 						constructor,
 						correspondingMemberNames,
-						canDeserialize ?? DetermineCanDeserialize(diag, constructorKind, options, targetType, correspondingMemberNames, allowDefault: true)
+						canDeserialize ?? DetermineCanDeserialize(constructorKind, options, targetType, correspondingMemberNames, allowDefault: true)
 					);
 			}
 		}
 
-		private static bool HasAnyCorrespondingMembers(IEnumerable<string?> correspondingMemberNames)
-			=> correspondingMemberNames.Count(x => !String.IsNullOrEmpty(x)) > 0;
-
-		private static bool HasDeserializableInterface(Type targetType, SerializerGenerationOptions options)
-			=> options.DeserializableInterfaceDetector(targetType, options);
+		private static readonly NaiveConcurrentFifoCache<string, NaiveConcurrentFifoCache<Assembly, bool>> s_areInternalsVisibleToCache =
+			new NaiveConcurrentFifoCache<string, NaiveConcurrentFifoCache<Assembly, bool>>(3);
 
-		private static bool DetermineCanDeserialize(DiagnosticSource diag, ConstructorKind kind, SerializerGenerationOptions options, Type targetType, IEnumerable<string?> correspondingMemberNames, bool allowDefault)
+		private static bool AreInternalsVisibleTo(Type type, ISerializerGenerationOptions options)
 		{
-			if (HasDeserializableInterface(targetType, options))
+			if (options.BindingOptions.AssumesInternalsVisibleTo)
 			{
-				diag.DetectedAsDeserializable(
-					new
+				return true;
+			}
+
+			var cacheExists = s_areInternalsVisibleToCache.TryGetValue(options.RuntimeCodeGenerationAssemblyName, out var areInternalsVisibleToCacheForGeneratingAssembly);
+
+			if (cacheExists && areInternalsVisibleToCacheForGeneratingAssembly!.TryGetValue(type.Assembly, out var areInternalsVisibleTo))
+			{
+				return areInternalsVisibleTo;
+			}
+
+			if (!cacheExists)
+			{
+				areInternalsVisibleToCacheForGeneratingAssembly = new NaiveConcurrentFifoCache<Assembly, bool>(10);
+				s_areInternalsVisibleToCache.Put(
+					options.RuntimeCodeGenerationAssemblyName,
+					areInternalsVisibleToCacheForGeneratingAssembly,
+					(old, _) => old // discard new one because it must be empty.
+				);
+			}
+
+			var result =
+				type.Assembly.GetCustomAttributes<InternalsVisibleToAttribute>().Any(
+					a =>
 					{
-						targetType,
-						constructorKind = "ImplementsInterface",
-						allowsDefault = allowDefault
+						var allowedAssembly = new AssemblyName(a.AssemblyName);
+						if (allowedAssembly.GetPublicKey() != null)
+						{
+							return false;
+						}
+
+						return allowedAssembly.Name == options.RuntimeCodeGenerationAssemblyName;
 					}
 				);
-				return true;
-			}
 
-			switch (kind)
+			areInternalsVisibleToCacheForGeneratingAssembly!.Put(
+				type.Assembly,
+				result,
+				(old, _) => old // 'old' and 'new' are always same, so pick up old here.
+			);
+			return result;
+		}
+
+		private static bool HasAnyCorrespondingMembers(IEnumerable<string?> correspondingMemberNames)
+			=> correspondingMemberNames.Count(x => !String.IsNullOrEmpty(x)) > 0;
+
+		private static bool HasDeserializableInterface(Type targetType, ISerializerGenerationOptions options)
+			=> options.CompatibilityOptions.DeserializableInterfaceDetectors.Any(d => d(targetType, options));
+
+		private static bool DetermineCanDeserialize(ConstructorKind kind, ISerializerGenerationOptions options, Type targetType, IEnumerable<string?> correspondingMemberNames, bool allowDefault)
+		{
+			if (HasDeserializableInterface(targetType, options))
 			{
-				case ConstructorKind.Marked:
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.DetectedAsDeserializable))
 				{
-					diag.DetectedAsDeserializable(
+					Diagnostic.GeneratorTrace.DetectedAsDeserializable(
 						new
 						{
 							targetType,
-							constructorKind = "MarkedWithAttribute",
+							constructorKind = "ImplementsInterface",
 							allowsDefault = allowDefault
 						}
 					);
+				}
+
+				return true;
+			}
+
+			switch (kind)
+			{
+				case ConstructorKind.Marked:
+				{
+					if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.DetectedAsDeserializable))
+					{
+						Diagnostic.GeneratorTrace.DetectedAsDeserializable(
+							new
+							{
+								targetType,
+								constructorKind = "MarkedWithAttribute",
+								allowsDefault = allowDefault
+							}
+						);
+					}
+
 					return true;
 				}
 				case ConstructorKind.Parameterful:
 				{
 					var result = HasAnyCorrespondingMembers(correspondingMemberNames);
-					diag.DetectedAsDeserializable(
-						new
-						{
-							targetType,
-							constructorKind = "Parameterful",
-							allowsDefault = allowDefault
-						}
-					);
+					if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.DetectedAsDeserializable))
+					{
+						Diagnostic.GeneratorTrace.DetectedAsDeserializable(
+							new
+							{
+								targetType,
+								constructorKind = "Parameterful",
+								allowsDefault = allowDefault
+							}
+						);
+					}
+
 					return result;
 				}
 				case ConstructorKind.Default:
 				{
-					diag.DetectedAsDeserializable(
-						new
-						{
-							targetType,
-							constructorKind = "Default",
-							allowsDefault = allowDefault
-						}
-					);
+					if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.DetectedAsDeserializable))
+					{
+						Diagnostic.GeneratorTrace.DetectedAsDeserializable(
+							new
+							{
+								targetType,
+								constructorKind = "Default",
+								allowsDefault = allowDefault
+							}
+						);
+					}
+
 					return allowDefault;
 				}
 				default:
@@ -338,11 +372,16 @@ private static MemberInfo[] GetDistinctMembers(Type type)
 			return distinctMembers.ToArray();
 		}
 
-		private static IEnumerable<SerializingMember> GetTargetMembers(Type type, SerializerGenerationOptions options)
+		private static IEnumerable<SerializingMember> GetTargetMembers(
+			Type targetType,
+			Func<string, Type, string?> correspondentParameterNameProvider,
+			ISerializerGenerationOptions options,
+			bool isInternalsVisible
+		)
 		{
-			Debug.Assert(type != null, "type != null");
+			Debug.Assert(targetType != null, "type != null");
 
-			var members = GetDistinctMembers(type);
+			var members = GetDistinctMembers(targetType);
 			var filtered =
 				members.Where(item =>
 					item.GetCustomAttributesData().Any(a => a.GetAttributeType().FullName == MessagePackMemberAttributeTypeName)
@@ -350,19 +389,26 @@ private static IEnumerable<SerializingMember> GetTargetMembers(Type type, Serial
 
 			if (filtered.Length > 0)
 			{
-				return GetAnnotatedMembersWithDuplicationDetection(type, filtered);
+				return GetAnnotatedMembersWithDuplicationDetection(targetType, filtered, correspondentParameterNameProvider, options, isInternalsVisible);
 			}
 
-			var compatibleMembers = GetCompatibleMembers(type.GetCustomAttributesData(), members, options).ToArray();
+			var typeAttributes = targetType.GetCustomAttributesData();
+			var compatibleMembers = GetCompatibleMembers(targetType, typeAttributes, members, correspondentParameterNameProvider, options, isInternalsVisible).ToArray();
 			if (compatibleMembers.Any())
 			{
 				return compatibleMembers;
 			}
 
-			return GetPublicUnpreventedMembers(members, options);
+			return GetPublicUnpreventedMembers(targetType, typeAttributes, members, correspondentParameterNameProvider, options, isInternalsVisible);
 		}
 
-		private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplicationDetection(Type type, MemberInfo[] filtered)
+		private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplicationDetection(
+			Type targetType,
+			MemberInfo[] filtered,
+			Func<string, Type, string?> correspondentParameterNameProvider,
+			ISerializerGenerationOptions options,
+			bool isInternalsVisible
+		)
 		{
 			var duplicated =
 				filtered.FirstOrDefault(
@@ -371,7 +417,7 @@ private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplication
 
 			if (duplicated != null)
 			{
-				Throw.MemberIsMarkedWithMemberAndIgnoreAttribute(type, duplicated.Name);
+				Throw.MemberIsMarkedWithMemberAndIgnoreAttribute(targetType, duplicated.Name);
 			}
 
 			return
@@ -379,15 +425,22 @@ private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplication
 					member =>
 					{
 						var attribute = member.GetCustomAttributesData().Single(a => a.GetAttributeType().FullName == MessagePackMemberAttributeTypeName);
+						var memberName = (string?)GetAttributeProperty(MessagePackMemberAttributeTypeName, attribute, "Name") ?? member.Name;
+						var memberType = member.GetMemberValueType();
+						var memberTraits = memberType.GetCollectionTraits(CollectionTraitOptions.Full, options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes);
+						var correspondentParameterName = correspondentParameterNameProvider(memberName, memberType);
 						return
-							new SerializingMember(
+								new SerializingMember(
 								member,
 								new DataMemberContract(
 									member,
-									(string?)GetAttributeProperty(MessagePackMemberAttributeTypeName, attribute, "Name"),
+									memberName,
 									(NilImplication)((int?)GetAttributeProperty(MessagePackMemberAttributeTypeName, attribute, "NilImplication")).GetValueOrDefault(),
 									(int?)GetAttributeArgument(MessagePackMemberAttributeTypeName, attribute, 0)
-								)
+								),
+								memberTraits,
+								GetAccessStrategy(targetType, member, memberTraits, options, isInternalsVisible, isSetter: false, correspondentParameterName),
+								GetAccessStrategy(targetType, member, memberTraits, options, isInternalsVisible, isSetter: true, correspondentParameterName)
 							);
 					}
 				);
@@ -417,78 +470,76 @@ private static IEnumerable<SerializingMember> GetAnnotatedMembersWithDuplication
 			return property.GetTypedValue().Value;
 		}
 
-		private static MessagePackMemberAttributeData? ProvideDefaultMessagePackMemberAttributeCompatibility(
+		private static IEnumerable<SerializingMember> GetCompatibleMembers(
+			Type targetType,
 			IEnumerable<CustomAttributeData> typeAttributes,
-			IEnumerable<CustomAttributeData> memberAttributes
+			MemberInfo[] members,
+			Func<string, Type, string?> correspondentParameterNameProvider,
+			ISerializerGenerationOptions options,
+			bool isInternalsVisible
 		)
-		{
-			if (!typeAttributes.Any(a => a.GetAttributeType().FullName == "System.Runtime.Serialization.DataContractAttribute"))
-			{
-				return null;
-			}
-
-			var dataMemberAttribute =
-				memberAttributes
-				.FirstOrDefault(a =>
-					a.GetAttributeType()
-					.FullName == "System.Runtime.Serialization.DataMemberAttribute"
-				);
-			if (dataMemberAttribute == null)
-			{
-				return null;
-			}
-
-			var name = default(string?);
-			var order = default(int?);
-			foreach(var namedArgument in dataMemberAttribute.GetNamedArguments())
-			{
-				var memberName = namedArgument.GetMemberName();
-				if (memberName == "Name")
-				{
-					name = (string?)namedArgument.GetTypedValue().Value;
-				}
-				else if(memberName == "Order")
-				{
-					order = (int?)namedArgument.GetTypedValue().Value;
-				}
-			}
-
-			return new MessagePackMemberAttributeData(order < 0 ? null : order, name);
-		}
-
-		private static IEnumerable<SerializingMember> GetCompatibleMembers(IEnumerable<CustomAttributeData> typeAttributes, MemberInfo[] members, SerializerGenerationOptions options)
-			=> members.Select(m => 
+			=> members.Select(m =>
 				(
 					Member: m,
-					Attribute: (options.MessagePackMemberAttributeCompatibilityProvider ?? ProvideDefaultMessagePackMemberAttributeCompatibility)
+					Attribute: (options.CompatibilityOptions.MessagePackMemberAttributeCompatibilityProvider)
 								.Invoke(typeAttributes, m.GetCustomAttributesData())
 				)
 			).Where(x => x.Attribute != null)
 			.Select(x =>
-				new SerializingMember(
-					x.Member,
-					// TODO: NilImplication
-					new DataMemberContract(x.Member, x.Attribute.GetValueOrDefault().Name, NilImplication.MemberDefault, x.Attribute.GetValueOrDefault().Id)
-				)
+				{
+					var memberName = x.Attribute.GetValueOrDefault().Name ?? x.Member.Name;
+					var memberType = x.Member.GetMemberValueType();
+					var memberTraits = memberType.GetCollectionTraits(CollectionTraitOptions.Full, options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes);
+					var correspondentParameterName = correspondentParameterNameProvider(memberName, memberType);
+					return
+						new SerializingMember(
+							x.Member,
+							new DataMemberContract(
+								x.Member,
+								memberName,
+								x.Attribute.GetValueOrDefault().NilImplication,
+								x.Attribute.GetValueOrDefault().Id
+							),
+							memberTraits,
+							GetAccessStrategy(targetType, x.Member, memberTraits, options, isInternalsVisible, isSetter: false, correspondentParameterName),
+							GetAccessStrategy(targetType, x.Member, memberTraits, options, isInternalsVisible, isSetter: true, correspondentParameterName)
+						);
+				}
 			);
 
-		private static IEnumerable<SerializingMember> GetPublicUnpreventedMembers(MemberInfo[] members, SerializerGenerationOptions options)
-		{
-			return members.Where(
+		private static IEnumerable<SerializingMember> GetPublicUnpreventedMembers(
+			Type targetType,
+			IEnumerable<CustomAttributeData> typeAttributes,
+			MemberInfo[] members,
+			Func<string, Type, string?> correspondentParameterNameProvider,
+			ISerializerGenerationOptions options,
+			bool isInternalsVisible
+		)
+			=> members.Where(
 				member =>
 					member.GetIsPublic()
-					&& !member
-#if !UNITY
-						.GetCustomAttributesData()
-						.Select(data => data.GetAttributeType().FullName!)
-#else
-						.GetCustomAttributes( true )
-						.Select(data => data.GetType().FullName)
-#endif // !UNITY
-						.Any(t => options.IgnoreAttributeTypeNames.Contains(t))
 					&& !IsNonSerializedField(member)
-				).Select(member => new SerializingMember(member, new DataMemberContract(member)));
-		}
+					&& options.CompatibilityOptions.IgnoringAttributeCompatibilityProvider(
+						typeAttributes, 
+						member.GetCustomAttributesData()
+					) is null
+					&& !IsNonSerializedField(member)
+			).Select(
+				(member, i) =>
+				{
+					var memberType = member.GetMemberValueType();
+					var memberTraits = memberType.GetCollectionTraits(CollectionTraitOptions.Full, options.CompatibilityOptions.AllowsNonCollectionEnumerableTypes);
+					var correspondentParameterName = correspondentParameterNameProvider(member.Name, memberType);
+					return
+						new SerializingMember(
+							member,
+							new DataMemberContract(member),
+							memberTraits,
+							GetAccessStrategy(targetType, member, memberTraits, options, isInternalsVisible, isSetter: false, correspondentParameterName),
+							GetAccessStrategy(targetType, member, memberTraits, options, isInternalsVisible, isSetter: true, correspondentParameterName)
+						);
+				}
+			);
 
 		private static bool IsNonSerializedField(MemberInfo member)
 		{
@@ -501,7 +552,7 @@ private static bool IsNonSerializedField(MemberInfo member)
 			return (asField.Attributes & FieldAttributes.NotSerialized) != 0;
 		}
 
-		private static ConstructorInfo? FindDeserializationConstructor(DiagnosticSource diag, SerializerGenerationOptions options, Type targetType, out ConstructorKind constructorKind)
+		private static ConstructorInfo? FindDeserializationConstructor(ISerializerGenerationOptions options, Type targetType, out ConstructorKind constructorKind)
 		{
 			var constructors = targetType.GetConstructors().ToArray();
 
@@ -548,13 +599,16 @@ private static bool IsNonSerializedField(MemberInfo member)
 			var mostRichConstructors =
 				constructors.GroupBy(ctor => ctor.GetParameters().Length).OrderByDescending(g => g.Key).First().ToArray();
 
-			diag.DeserializationConstructorFound(
-				new
-				{
-					targetType = targetType,
-					constructors = mostRichConstructors.Select(x => x.ToString()).ToArray()
-				}
-			);
+			if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.DeserializationConstructorFound))
+			{
+				Diagnostic.GeneratorTrace.DeserializationConstructorFound(
+					new
+					{
+						targetType,
+						constructors = mostRichConstructors.Select(x => x.ToString()).ToArray()
+					}
+				);
+			}
 
 			switch (mostRichConstructors.Length)
 			{
@@ -615,71 +669,319 @@ private static IList<ConstructorInfo> FindExplicitDeserializationConstructors(IE
 				).ToArray();
 		}
 
-
-		private static bool CheckTargetEligibility(SerializerGenerationOptions options, MemberInfo member)
+		private static MemberAccessStrategy GetAccessStrategy(
+			Type targetType,
+			MemberInfo member,
+			CollectionTraits memberTraits,
+			ISerializerGenerationOptions options,
+			bool isInternalsVisible,
+			bool isSetter,
+			string? correspondentParameterName
+		)
 		{
-			Type returnType;
+			var isPublic = false;
+			var isAssembly = false;
+			var isReadOnly = false;
+
+			// 1. Check member. Static, literal, or setonly member should be skipped.
+			if (member is FieldInfo asField)
+			{
+				if (asField.IsStatic || asField.IsLiteral)
+				{
+					if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.SkipStaticMember))
+					{
+						Diagnostic.GeneratorTrace.SkipStaticMember(
+							new
+							{
+								targetMember = member
+							}
+						);
+					}
 
-			if (member is PropertyInfo asProperty)
+					return MemberAccessStrategy.Skip;
+				}
+
+				isPublic = asField.IsPublic;
+				isAssembly = asField.IsAssembly || asField.IsFamilyOrAssembly;
+				isReadOnly = asField.IsInitOnly;
+			}
+			else
 			{
+				var asProperty = member as PropertyInfo;
+				Debug.Assert(asProperty != null);
+
 				if (asProperty.GetIndexParameters().Length > 0)
 				{
-					// Indexer cannot be target except the type itself implements IDictionary or IDictionary<TKey,TValue>
-					return false;
+					if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.SkipIndexer))
+					{
+						Diagnostic.GeneratorTrace.SkipIndexer(
+							new
+							{
+								targetMember = member
+							}
+						);
+					}
+
+					return MemberAccessStrategy.Skip;
 				}
 
-#if !NETSTANDARD1_1 && !NETSTANDARD1_3
-				var setter = asProperty.GetSetMethod(true);
-#else
-				var setter = asProperty.SetMethod;
-#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
-				if (setter != null)
+				if (!isSetter)
 				{
-					if (setter.GetIsPublic())
+					var getter = asProperty.GetGetMethod(nonPublic: true);
+					if (getter == null)
 					{
-						return true;
+						if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.SkipSetOnlyProperty))
+						{
+							Diagnostic.GeneratorTrace.SkipSetOnlyProperty(
+								new
+								{
+									targetMember = member
+								}
+							);
+						}
+
+						return MemberAccessStrategy.Skip;
 					}
 
-					if (!options.DisablesPrivilegedAccess)
+					if (getter.IsStatic)
 					{
-						// Can deserialize non-public setter if privileged.
-						return true;
+						if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.SkipStaticMember))
+						{
+							Diagnostic.GeneratorTrace.SkipStaticMember(
+								new
+								{
+									targetMember = member
+								}
+							);
+						}
+
+						return MemberAccessStrategy.Skip;
+					}
+
+					isPublic = getter.IsPublic;
+					isAssembly = getter.IsAssembly || getter.IsFamilyOrAssembly;
+				}
+				else
+				{
+					var setter = asProperty.GetSetMethod(nonPublic: true);
+					if (setter != null)
+					{
+						if (setter.IsStatic)
+						{
+							if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.SkipStaticMember))
+							{
+								Diagnostic.GeneratorTrace.SkipStaticMember(
+									new
+									{
+										targetMember = member
+									}
+								);
+							}
+
+							return MemberAccessStrategy.Skip;
+						}
+
+						isPublic = setter.IsPublic;
+						isAssembly = setter.IsAssembly || setter.IsFamilyOrAssembly;
+					}
+					else
+					{
+						isReadOnly = true;
 					}
 				}
+			}
 
-				returnType = asProperty.PropertyType;
+			// 2. If field/property is init only, we MAY set it via ctor.
+			if (isSetter && isReadOnly)
+			{
+				return GetAccessStrategyForReadOnlyMember(targetType, member, memberTraits, options, correspondentParameterName);
 			}
-			else if (member is FieldInfo asField)
+
+			// 3. If runtime code generation is disabled, we can only use reflection anyway.
+			if (options.IsRuntimeCodeGenerationDisabled)
 			{
-				if (!asField.IsInitOnly)
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseReflectionMemberAccess))
 				{
-					return true;
+					Diagnostic.GeneratorTrace.UseReflectionMemberAccess(
+						new
+						{
+							targetMember = member
+						}
+					);
 				}
 
-				returnType = asField.FieldType;
+				// Use reflection
+				return MemberAccessStrategy.WithReflection;
 			}
-			else
+
+			// 4. If target is public, we can access it directly.
+			if (isPublic)
 			{
-				Debug.Fail($"Unknown type member '{member}'");
-				return true;
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseDirectMemberAccessDueToPublic))
+				{
+					Diagnostic.GeneratorTrace.UseDirectMemberAccessDueToPublic(
+						new
+						{
+							targetMember = member
+						}
+					);
+				}
+
+				return MemberAccessStrategy.Direct;
+			}
+
+			// 5. If assembly builder can access to target internals and target's accessibility is assembly, then we can use it directly.
+			if (isInternalsVisible)
+			{
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseDirectMemberAccessDueToInternalsVisibleTo))
+				{
+					Diagnostic.GeneratorTrace.UseDirectMemberAccessDueToInternalsVisibleTo(
+						new
+						{
+							targetMember = member,
+							generatingAssembly = options.RuntimeCodeGenerationAssemblyName
+						}
+					);
+				}
+
+				return MemberAccessStrategy.Direct;
+			}
+
+			// 6. If privileged access is disabled, we can only use constructor.
+			if (!options.BindingOptions.IsPrivilegedAccessDisabled)
+			{
+				if (isSetter && correspondentParameterName != null)
+				{
+					if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseConstructorForMemberAccessDueToAccessibility))
+					{
+						Diagnostic.GeneratorTrace.UseConstructorForMemberAccessDueToAccessibility(
+							new
+							{
+								targetMember = member,
+								correspondentParameterName
+							}
+						);
+					}
+
+					return MemberAccessStrategy.ViaConstrutor;
+				}
+
+				// Skip this member for now -- it leads exception when no accessible members available.
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.SkipMemberDueToAccessibility))
+				{
+					Diagnostic.GeneratorTrace.SkipMemberDueToAccessibility(
+						new
+						{
+							targetMember = member
+						}
+					);
+				}
+
 			}
 
-			var traits = returnType.GetCollectionTraits(CollectionTraitOptions.WithAddMethod, allowNonCollectionEnumerableTypes: false);
-			switch (traits.CollectionType)
+#if FEATURE_IGNORE_ACCESS_CHECKS_TO_ATTRIBUTE
+			// 7. Use System.Runtime.CompilerServices.IgnoreAccessChecksToAttribute if possible in current platform.
+			if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseIgnoreAccessChecksToAttributeForMemberAccess))
+			{
+				Diagnostic.GeneratorTrace.UseIgnoreAccessChecksToAttributeForMemberAccess(
+					new
+					{
+						targetMember = member
+					}
+				);
+			}
+
+			return MemberAccessStrategy.DirectWithIgnoreAccessChecksToAttribute;
+#else
+
+			// 8. Now, we can use delegate.
+			//    Delegate creation may throw MemberAccessException when required code access security permission is not grant,
+			//    however, in such case, we cannot [de]serialize target type anyway.
+			if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseDelegateForMemberAccess))
+			{
+				Diagnostic.GeneratorTrace.UseDelegateForMemberAccess(
+					new
+					{
+						targetMember = member
+					}
+				);
+			}
+
+			return MemberAccessStrategy.ViaDelegate;
+#endif
+		}
+
+		private static MemberAccessStrategy GetAccessStrategyForReadOnlyMember(Type targetType, MemberInfo member, CollectionTraits memberTraits, ISerializerGenerationOptions options, string? correspondentParameterName)
+		{
+			if (correspondentParameterName != null)
+			{
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseConstructorForMemberAccessDueToReadOnly))
+				{
+					Diagnostic.GeneratorTrace.UseConstructorForMemberAccessDueToReadOnly(
+						new
+						{
+							targetMember = member,
+							correspondentParameterName
+						}
+					);
+				}
+
+				return MemberAccessStrategy.ViaConstrutor;
+			}
+
+			switch (memberTraits.CollectionType)
 			{
 				case CollectionKind.Array:
 				case CollectionKind.Map:
 				{
-					return traits.AddMethod != null;
+					if (memberTraits.AddMethod != null)
+					{
+						if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.UseCollectionAddForReadOnlyMember))
+						{
+							Diagnostic.GeneratorTrace.UseCollectionAddForReadOnlyMember(
+								new
+								{
+									targetMember = member,
+									correspondentParameterName
+								}
+							);
+						}
+
+						return MemberAccessStrategy.CollectionAdd;
+					}
+
+					break;
 				}
 				default:
 				{
-					return false;
+					break;
 				}
 			}
+
+			if (options.AllowsAsymmetricSerializer)
+			{
+				if (Diagnostic.GeneratorTrace.IsEnabled(Diagnostic.GeneratorTrace.Keys.WillBeAsymmetricDueToReadOnlyMember))
+				{
+					Diagnostic.GeneratorTrace.WillBeAsymmetricDueToReadOnlyMember(
+						new
+						{
+							targetType,
+							targetMember = member,
+							correspondentParameterName
+						}
+					);
+				}
+
+				return MemberAccessStrategy.WillBeAsymmetric;
+			}
+			else
+			{
+				Throw.CannotSerializeTypeWhichDeclaresReadOnlySignificantNonCollectionMemberWhenAsymmetricSerializerIsNotAllowed(targetType, member);
+				return default; // never reaches
+			}
 		}
 
-		private static IReadOnlyList<SerializingMember> ComplementMembers(IReadOnlyList<SerializingMember> candidates, SerializerGenerationOptions options, Type targetType)
+		private static IReadOnlyList<SerializingMember> ComplementMembers(IReadOnlyList<SerializingMember> candidates, ISerializationCompatibilityOptions options, Type targetType)
 		{
 			if (candidates.Count == 0)
 			{
@@ -691,7 +993,7 @@ private static IReadOnlyList<SerializingMember> ComplementMembers(IReadOnlyList<
 				return candidates;
 			}
 
-			if (options.OneBoundDataMemberOrder && candidates[0].Contract.Id == 0)
+			if (options.UsesOneBoundDataMemberOrder && candidates[0].Contract.Id == 0)
 			{
 				Throw.DataMemberAttributeCannotBeZeroWhenOneBoundDataMemberOrderIsTrue(targetType, candidates[0].MemberName);
 			}
@@ -706,7 +1008,7 @@ private static IReadOnlyList<SerializingMember> ComplementMembers(IReadOnlyList<
 			}
 #endif
 			var result = new List<SerializingMember>(maxId + 1);
-			for (int source = 0, destination = options.OneBoundDataMemberOrder ? 1 : 0;
+			for (int source = 0, destination = options.UsesOneBoundDataMemberOrder ? 1 : 0;
 				source < candidates.Count;
 				source++, destination++)
 			{
@@ -803,7 +1105,7 @@ private static void VerifyKeyUniqueness(IList<SerializingMember> result)
 			}
 		}
 
-		public static SerializationTarget CreateForCollection(Type targetType, CollectionTraits traits, ConstructorInfo collectionConstructor, bool canDeserialize)
+		public static SerializationTarget CreateForCollection(Type targetType, CollectionTraits traits, ConstructorInfo? collectionConstructor, bool canDeserialize)
 			=> new SerializationTarget(targetType, traits, Array.Empty<SerializingMember>(), collectionConstructor, Array.Empty<string>(), canDeserialize);
 
 		public static SerializationTarget CreateForTuple(Type targetType)
@@ -827,6 +1129,43 @@ public static bool BuiltInSerializerExists( ISerializerGeneratorConfiguration co
 		}
 #endif // FEATURE_CODEGEN
 
+		private sealed class ConstructorParameterMapping
+		{
+			private readonly Dictionary<string, string> _parameterMemberMapping;
+			private readonly Dictionary<string, ParameterInfo> _parametersLookup;
+
+			public ConstructorParameterMapping(ParameterInfo[] parameters)
+			{
+				this._parametersLookup = parameters.ToDictionary(p => p.Name!, StringComparer.OrdinalIgnoreCase);
+				this._parameterMemberMapping = new Dictionary<string, string>(parameters.Length);
+			}
+
+			public string? GetMappedParameterName(string memberName, Type memberType)
+			{
+				if (!this._parametersLookup.TryGetValue(memberName, out var parameter) || parameter.ParameterType != memberType)
+				{
+					return null;
+				}
+
+				if (!this._parameterMemberMapping.TryAdd(parameter.Name!, memberName))
+				{
+					Throw.CannotDetectCorrepondentMemberNameUniquely(
+						parameter,
+						new [] { this._parameterMemberMapping[parameter.Name!], memberName }
+					);
+				}
+
+				return parameter.Name;
+			}
+
+			public string?[] GetCorrespondentMemberNames()
+				=> this._parametersLookup
+					.Values
+					.OrderBy(p => p.Position)
+					.Select(p => this._parameterMemberMapping.TryGetValue(p.Name!, out var memberName) ? memberName : null)
+					.ToArray();
+		}
+
 		private sealed class MemberConstructorParameterEqualityComparer : EqualityComparer<KeyValuePair<string, Type>>
 		{
 			public static readonly IEqualityComparer<KeyValuePair<string, Type>> Instance = new MemberConstructorParameterEqualityComparer();
diff --git a/src/MsgPack/Serialization/SerializerRegistrationOptions.cs b/src/MsgPack/Serialization/SerializerRegistrationOptions.cs
index ef740d3fc..fdb19497b 100644
--- a/src/MsgPack/Serialization/SerializerRegistrationOptions.cs
+++ b/src/MsgPack/Serialization/SerializerRegistrationOptions.cs
@@ -1,26 +1,6 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2015 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 
@@ -43,6 +23,7 @@ public enum SerializerRegistrationOptions
 		AllowOverride = 0x1,
 
 #if !UNITY
+#warning TODO: Test in newest Unity
 		// Unity causes AOT error for auto nullable registration...
 		/// <summary>
 		///		For non-nullable value type, registering nullable companion simulary.
@@ -50,4 +31,4 @@ public enum SerializerRegistrationOptions
 		WithNullable = 0x2
 #endif // !UNITY
 	}
-}
\ No newline at end of file
+}
diff --git a/src/MsgPack/Serialization/SerializingMember.cs b/src/MsgPack/Serialization/SerializingMember.cs
index 912f10069..197255487 100644
--- a/src/MsgPack/Serialization/SerializingMember.cs
+++ b/src/MsgPack/Serialization/SerializingMember.cs
@@ -3,7 +3,6 @@
 // See the LICENSE in the project root for more information.
 
 using System;
-using System.Diagnostics;
 using System.Reflection;
 
 namespace MsgPack.Serialization
@@ -17,14 +16,20 @@ internal readonly struct SerializingMember
 		public DataMemberContract Contract { get; }
 		public string MemberName { get; }
 		public Utf8String Utf8MemberName { get; }
+		public CollectionTraits CollectionTraits { get; }
+		public MemberAccessStrategy GetterAccessStrategy { get; }
+		public MemberAccessStrategy SetterAccessStrategy { get; }
 
-		public SerializingMember(MemberInfo member, DataMemberContract contract)
+		public SerializingMember(MemberInfo member, DataMemberContract contract, CollectionTraits traits, MemberAccessStrategy getterAccessStrategy, MemberAccessStrategy setterAccessStrategy)
 		{
 			this.Member = member;
 			this.Contract = contract;
 			// Use contract name for aliased map serialization.
 			this.MemberName = contract.Name;
 			this.Utf8MemberName = new Utf8String(contract.Name);
+			this.CollectionTraits = traits;
+			this.GetterAccessStrategy = getterAccessStrategy;
+			this.SetterAccessStrategy = setterAccessStrategy;
 		}
 
 		// for tuple
@@ -35,6 +40,11 @@ public SerializingMember(MemberInfo member, string name)
 			// Use contract name for aliased map serialization.
 			this.MemberName = name;
 			this.Utf8MemberName = new Utf8String(name);
+			// Tuple is not collection.
+			this.CollectionTraits = CollectionTraits.NotCollection;
+			// Tuples always have public getters.
+			this.GetterAccessStrategy = MemberAccessStrategy.Direct;
+			this.SetterAccessStrategy = MemberAccessStrategy.ViaConstrutor;
 		}
 
 		public EnumMemberSerializationMethod GetEnumMemberSerializationMethod()
diff --git a/src/MsgPack/Serialization/TypeKeyRepository.cs b/src/MsgPack/Serialization/TypeKeyRepository.cs
index 1bbd08ef7..1f2f0006e 100644
--- a/src/MsgPack/Serialization/TypeKeyRepository.cs
+++ b/src/MsgPack/Serialization/TypeKeyRepository.cs
@@ -1,64 +1,40 @@
-#region -- License Terms --
-//
-// MessagePack for CLI
-//
-// Copyright (C) 2010-2016 FUJIWARA, Yusuke
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-//
-#endregion -- License Terms --
-
-#if UNITY_5 || UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT
-#define UNITY
-#endif
+// Copyright (c) FUJIWARA, Yusuke and all contributors.
+// This file is licensed under Apache2 license.
+// See the LICENSE in the project root for more information.
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
-#if FEATURE_MPCONTRACT
-using Contract = MsgPack.MPContract;
-#else
-using System.Diagnostics.Contracts;
-#endif // FEATURE_MPCONTRACT
-#if NETFX_CORE
-using System.Reflection;
-#endif
 using System.Runtime.CompilerServices;
-using System.Threading;
+#if FEATURE_CODE_ACCESS_SECURITY
 using System.Security;
+#endif // FEATURE_CODE_ACCESS_SECURITY
+using System.Threading;
 
 namespace MsgPack.Serialization
 {
 	/// <summary>
 	///		Repository for key type with RWlock scheme.
 	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Repository should not be disposable because it may be shared so it is difficult to determine disposition timing" )]
-#if !NET35 && !UNITY
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Repository should not be disposable because it may be shared so it is difficult to determine disposition timing")]
+#if FEATURE_CODE_ACCESS_SECURITY
 	[SecuritySafeCritical]
-#endif
+#endif // FEATURE_CODE_ACCESS_SECURITY
 	internal class TypeKeyRepository
 	{
 		private readonly ReaderWriterLockSlim _lock;
 
+		// We use RuntimeTypeHandle because it is bit faster than Type.
 		private readonly Dictionary<RuntimeTypeHandle, object> _table;
 
-		public TypeKeyRepository() : this( default( TypeKeyRepository ) ) { }
+		public TypeKeyRepository() : this(default(TypeKeyRepository)) { }
 
-		public TypeKeyRepository( TypeKeyRepository copiedFrom )
+		public TypeKeyRepository(TypeKeyRepository? copiedFrom)
 		{
-			this._lock = new ReaderWriterLockSlim( LockRecursionPolicy.NoRecursion );
+			this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
 
-			if ( copiedFrom == null )
+			if (copiedFrom == null)
 			{
 				this._table = new Dictionary<RuntimeTypeHandle, object>();
 			}
@@ -68,60 +44,54 @@ public TypeKeyRepository( TypeKeyRepository copiedFrom )
 			}
 		}
 
-		public TypeKeyRepository( Dictionary<RuntimeTypeHandle, object> table )
+		public TypeKeyRepository(Dictionary<RuntimeTypeHandle, object> table)
 		{
-			this._lock = new ReaderWriterLockSlim( LockRecursionPolicy.NoRecursion );
+			this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
 			this._table = table;
 		}
 
-#if !NET35 && !UNITY
+#if FEATURE_CODE_ACCESS_SECURITY
 		[SecuritySafeCritical]
-#endif
-#if NET35 || UNITY
 		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK" )]
-#endif // NET35 || UNITY
-		private Dictionary<RuntimeTypeHandle, object> GetClonedTable()
+#endif // FEATURE_CODE_ACCESS_SECURITY
+		internal Dictionary<RuntimeTypeHandle, object> GetClonedTable()
 		{
-			bool holdsReadLock = false;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+			var holdsReadLock = false;
+#if FEATURE_CER
 			RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 			try
 			{
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_CER
 				RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 				try { }
 				finally
 				{
 					this._lock.EnterReadLock();
 					holdsReadLock = true;
 				}
-				return new Dictionary<RuntimeTypeHandle, object>( this._table );
+				return new Dictionary<RuntimeTypeHandle, object>(this._table);
 			}
 			finally
 			{
-				if ( holdsReadLock )
+				if (holdsReadLock)
 				{
 					this._lock.ExitReadLock();
 				}
 			}
 		}
 
-		public bool Get( Type type, out object matched, out object genericDefinitionMatched )
-		{
-			return this.GetCore( type, out matched, out genericDefinitionMatched );
-		}
+		public bool Get(Type type, out object? matched, out object? genericDefinitionMatched)
+			=> this.GetCore(type, out matched, out genericDefinitionMatched);
 
-#if !NET35 && !UNITY
+#if FEATURE_CODE_ACCESS_SECURITY
 		[SecuritySafeCritical]
-#endif
-#if NET35 || UNITY
 		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK" )]
-#endif // NET35 || UNITY
-		private bool GetCore( Type type, out object matched, out object genericDefinitionMatched )
+#endif // FEATURE_CODE_ACCESS_SECURITY
+		private bool GetCore(Type type, out object? matched, out object? genericDefinitionMatched)
 		{
-			bool holdsReadLock = false;
+			var holdsReadLock = false;
 #if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
 			RuntimeHelpers.PrepareConstrainedRegions();
 #endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
@@ -136,77 +106,57 @@ private bool GetCore( Type type, out object matched, out object genericDefinitio
 					this._lock.EnterReadLock();
 					holdsReadLock = true;
 				}
-				object result;
-				if ( this._table.TryGetValue( type.TypeHandle, out result ) )
-				{
-					matched = result;
-					genericDefinitionMatched = null;
-					return true;
-				}
 
-				if ( type.GetIsGenericType() )
-				{
-					if ( this._table.TryGetValue( type.GetGenericTypeDefinition().TypeHandle, out result ) )
-					{
-						matched = null;
-						genericDefinitionMatched = result;
-						return true;
-					}
-				}
-
-				matched = null;
-				genericDefinitionMatched = null;
-				return false;
+				return TypeKeyRepositoryLogics.TryGet(this._table, type, out matched, out genericDefinitionMatched);
 			}
 			finally
 			{
-				if ( holdsReadLock )
+				if (holdsReadLock)
 				{
 					this._lock.ExitReadLock();
 				}
 			}
 		}
 
-		public bool Register( Type type, object entry, Type nullableType, object nullableValue, SerializerRegistrationOptions options )
+		public bool Register(Type type, object entry, Type? nullableType, object? nullableValue, SerializerRegistrationOptions options)
 		{
-			Contract.Assert( entry != null, "entry != null" );
+			Debug.Assert(entry != null, "entry != null");
 
-			return this.RegisterCore( type, entry, nullableType, nullableValue, options );
+			return this.RegisterCore(type, entry, nullableType, nullableValue, options);
 		}
 
-#if !NET35 && !UNITY
+#if FEATURE_CODE_ACCESS_SECURITY
 		[SecuritySafeCritical]
-#endif
-#if NET35 || UNITY
 		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK" )]
-#endif // NET35 || UNITY
-		private bool RegisterCore( Type key, object value, Type nullableType, object nullableValue, SerializerRegistrationOptions options )
+#endif //FEATURE_CODE_ACCESS_SECURITY
+		private bool RegisterCore(Type key, object value, Type? nullableType, object? nullableValue, SerializerRegistrationOptions options)
 		{
-			var allowOverwrite = ( options & SerializerRegistrationOptions.AllowOverride ) != 0;
+			var allowOverwrite = (options & SerializerRegistrationOptions.AllowOverride) != 0;
 
-			if ( allowOverwrite || !this.ContainsType( key, nullableType ) )
+			if (allowOverwrite || !this.ContainsType(key, nullableType))
 			{
-				bool holdsWriteLock = false;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+				var holdsWriteLock = false;
+#if FEATURE_CER
 				RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 				try
 				{
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_CER
 					RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 					try { }
 					finally
 					{
 						this._lock.EnterWriteLock();
 						holdsWriteLock = true;
 					}
-					if ( allowOverwrite || !this.ContainsType( key, nullableType ) )
+					if (allowOverwrite || !this.ContainsType(key, nullableType))
 					{
-						this._table[ key.TypeHandle ] = value;
-						if ( nullableValue != null )
+						this._table[key.TypeHandle] = value;
+						if (nullableValue != null)
 						{
-							this._table[ nullableType.TypeHandle ] = nullableValue;
+							Debug.Assert(nullableType != null);
+							this._table[nullableType.TypeHandle] = nullableValue;
 						}
 
 						return true;
@@ -214,7 +164,7 @@ private bool RegisterCore( Type key, object value, Type nullableType, object nul
 				}
 				finally
 				{
-					if ( holdsWriteLock )
+					if (holdsWriteLock)
 					{
 						this._lock.ExitWriteLock();
 					}
@@ -224,55 +174,88 @@ private bool RegisterCore( Type key, object value, Type nullableType, object nul
 			return false;
 		}
 
-		private bool ContainsType( Type baseType, Type nullableType )
+#if FEATURE_CODE_ACCESS_SECURITY
+		[SecuritySafeCritical]
+		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK" )]
+#endif //FEATURE_CODE_ACCESS_SECURITY
+		internal void Import(IEnumerable<KeyValuePair<RuntimeTypeHandle, object>> tableData)
+		{
+			var holdsWriteLock = false;
+#if FEATURE_CER
+			RuntimeHelpers.PrepareConstrainedRegions();
+#endif // FEATURE_CER
+			try
+			{
+#if FEATURE_CER
+				RuntimeHelpers.PrepareConstrainedRegions();
+#endif // FEATURE_CER
+				try { }
+				finally
+				{
+					this._lock.EnterWriteLock();
+					holdsWriteLock = true;
+				}
+
+				this._table.Clear();
+				foreach(var entry in tableData)
+				{
+					this._table.Add(entry.Key, entry.Value);
+				}
+			}
+			finally
+			{
+				if (holdsWriteLock)
+				{
+					this._lock.ExitWriteLock();
+				}
+			}
+		}
+
+		private bool ContainsType(Type baseType, Type? nullableType)
 		{
-			if ( nullableType == null )
+			if (nullableType == null)
 			{
-				return this._table.ContainsKey( baseType.TypeHandle );
+				return this._table.ContainsKey(baseType.TypeHandle);
 			}
 			else
 			{
 				return
-					this._table.ContainsKey( baseType.TypeHandle )
-					&& this._table.ContainsKey( nullableType.TypeHandle );
+					this._table.ContainsKey(baseType.TypeHandle)
+					&& this._table.ContainsKey(nullableType.TypeHandle);
 			}
 		}
 
-		public bool Unregister( Type type )
-		{
-			return this.UnregisterCore( type );
-		}
+		public bool Unregister(Type type)
+			=> this.UnregisterCore(type);
 
-#if !NET35 && !UNITY
+#if FEATURE_CODE_ACCESS_SECURITY
 		[SecuritySafeCritical]
-#endif
-#if NET35 || UNITY
 		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK" )]
-#endif // NET35 || UNITY
-		private bool UnregisterCore( Type key )
+#endif // FEATURE_CODE_ACCESS_SECURITY
+		private bool UnregisterCore(Type key)
 		{
-			if ( this._table.ContainsKey( key.TypeHandle ) )
+			if (this._table.ContainsKey(key.TypeHandle))
 			{
-				bool holdsWriteLock = false;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+				var holdsWriteLock = false;
+#if FEATURE_CER
 				RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 				try
 				{
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_CER
 					RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 					try { }
 					finally
 					{
 						this._lock.EnterWriteLock();
 						holdsWriteLock = true;
 					}
-					return this._table.Remove( key.TypeHandle );
+					return this._table.Remove(key.TypeHandle);
 				}
 				finally
 				{
-					if ( holdsWriteLock )
+					if (holdsWriteLock)
 					{
 						this._lock.ExitWriteLock();
 					}
@@ -282,62 +265,64 @@ private bool UnregisterCore( Type key )
 			return false;
 		}
 
-#if !NET35 && !UNITY
+#if FEATURE_CODE_ACCESS_SECURITY
 		[SecuritySafeCritical]
-#endif
-		internal bool Contains( Type type )
+		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK" )]
+#endif // FEATURE_CODE_ACCESS_SECURITY
+		internal bool Contains(Type type)
 		{
-			bool holdsReadLock = false;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+			var holdsReadLock = false;
+#if FEATURE_CER
 			RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 			try
 			{
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_CER
 				RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 				try { }
 				finally
 				{
 					this._lock.EnterReadLock();
 					holdsReadLock = true;
 				}
-				return this._table.ContainsKey( type.TypeHandle );
+				return this._table.ContainsKey(type.TypeHandle);
 			}
 			finally
 			{
-				if ( holdsReadLock )
+				if (holdsReadLock)
 				{
 					this._lock.ExitReadLock();
 				}
 			}
 		}
 
-#if !NET35 && !UNITY
+#if FEATURE_CODE_ACCESS_SECURITY
 		[SecuritySafeCritical]
-#endif
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "CER is OK")]
+#endif // FEATURE_CODE_ACCESS_SECURITY
 		internal IEnumerable<KeyValuePair<Type, object>> GetEntries()
 		{
-			bool holdsReadLock = false;
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+			var holdsReadLock = false;
+#if FEATURE_CER
 			RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 			try
 			{
-#if !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#if FEATURE_CER
 				RuntimeHelpers.PrepareConstrainedRegions();
-#endif // !SILVERLIGHT && !NETSTANDARD1_1 && !NETSTANDARD1_3
+#endif // FEATURE_CER
 				try { }
 				finally
 				{
 					this._lock.EnterReadLock();
 					holdsReadLock = true;
 				}
-				return this._table.Select( kv => new KeyValuePair<Type, object>( Type.GetTypeFromHandle( kv.Key ), kv.Value ) ).ToArray();
+				return this._table.Select(kv => new KeyValuePair<Type, object>(Type.GetTypeFromHandle(kv.Key), kv.Value)).ToArray();
 			}
 			finally
 			{
-				if ( holdsReadLock )
+				if (holdsReadLock)
 				{
 					this._lock.ExitReadLock();
 				}